optimized face sample generator, CPU load is significantly reduced

SAEHD:

added new option
GAN power 0.0 .. 10.0
	Train the network in Generative Adversarial manner.
	Forces the neural network to learn small details of the face.
	You can enable/disable this option at any time,
	but better to enable it when the network is trained enough.
	Typical value is 1.0
	GAN power with pretrain mode will not work.

Example of enabling GAN on 81k iters +5k iters
https://i.imgur.com/OdXHLhU.jpg
https://i.imgur.com/CYAJmJx.jpg

dfhd: default Decoder dimensions are now 48
the preview for 256 res is now correctly displayed

fixed model naming/renaming/removing

Improvements for those involved in post-processing in AfterEffects:

Codec is reverted back to x264 in order to properly use in AfterEffects and video players.

Merger now always outputs the mask to workspace\data_dst\merged_mask

removed raw modes except raw-rgb
raw-rgb mode now outputs selected face mask_mode (before square mask)

'export alpha mask' button is replaced by 'show alpha mask'.
You can view the alpha mask without recompute the frames.

8) 'merged *.bat' now also output 'result_mask.' video file.
8) 'merged lossless' now uses x264 lossless codec (before PNG codec)
result_mask video file is always lossless.

Thus you can use result_mask video file as mask layer in the AfterEffects.

core/leras/layers.py

@@ -78,26 +78,7 @@ def initialize_layers(nn):
             return True
 
         def init_weights(self):
-            ops = []
-
-            ca_tuples_w = []
-            ca_tuples = []
-            for w in self.get_weights():
-                initializer = w.initializer
-                for input in initializer.inputs:
-                    if "_cai_" in input.name:
-                        ca_tuples_w.append (w)
-                        ca_tuples.append ( (w.shape.as_list(), w.dtype.as_numpy_dtype) )
-                        break
-                else:
-                    ops.append (initializer)
-
-            if len(ops) != 0:
-                nn.tf_sess.run (ops)
-
-            if len(ca_tuples) != 0:
-                nn.tf_batch_set_value( [*zip(ca_tuples_w, nn.initializers.ca.generate_batch (ca_tuples))] )
-
+            nn.tf_init_weights(self.get_weights())
     nn.Saveable = Saveable
 
     class LayerBase():
@@ -302,7 +283,8 @@ def initialize_layers(nn):
                 raise ValueError ("strides must be an int type")
             if not isinstance(dilations, int):
                 raise ValueError ("dilations must be an int type")
-
+            kernel_size = int(kernel_size)
+            
             if dtype is None:
                 dtype = nn.tf_floatx
 
@@ -405,7 +387,8 @@ def initialize_layers(nn):
         def __init__(self, in_ch, out_ch, kernel_size, strides=2, padding='SAME', use_bias=True, use_wscale=False, kernel_initializer=None, bias_initializer=None, trainable=True, dtype=None, **kwargs ):
             if not isinstance(strides, int):
                 raise ValueError ("strides must be an int type")
-
+            kernel_size = int(kernel_size)
+            
             if dtype is None:
                 dtype = nn.tf_floatx
 

core/leras/models.py

@@ -0,0 +1,41 @@
+def initialize_models(nn):
+    tf = nn.tf
+  
+
+        
+    class PatchDiscriminator(nn.ModelBase):
+        def on_build(self, patch_size, in_ch, base_ch=256, kernel_initializer=None):
+            prev_ch = in_ch
+            self.convs = []            
+            for i, (kernel_size, strides) in enumerate(patch_discriminator_kernels[patch_size]):
+                cur_ch = base_ch * min( (2**i), 8 )
+                self.convs.append ( nn.Conv2D( prev_ch, cur_ch, kernel_size=kernel_size, strides=strides, padding='SAME', kernel_initializer=kernel_initializer) )
+                prev_ch = cur_ch
+
+            self.out_conv =  nn.Conv2D( prev_ch, 1, kernel_size=1, padding='VALID', kernel_initializer=kernel_initializer)
+
+        def forward(self, x):
+            for conv in self.convs:
+                x = tf.nn.leaky_relu( conv(x), 0.1 )
+            return self.out_conv(x)
+            
+    nn.PatchDiscriminator = PatchDiscriminator
+    
+    
+patch_discriminator_kernels = \
+    { 1 : [ [1,1] ],             
+      2 : [ [2,1] ],
+      3 : [ [2,1], [2,1] ],        
+      4 : [ [2,2], [2,2] ],        
+      5 : [ [3,2], [2,2] ],        
+      6 : [ [4,2], [2,2] ],
+      7 : [ [3,2], [3,2] ],        
+      8 : [ [4,2], [3,2] ],        
+      9 : [ [3,2], [4,2] ], 
+      10 : [ [4,2], [4,2] ], 
+      11 : [ [3,2], [3,2], [2,1] ], 
+      12 : [ [4,2], [3,2], [2,1] ], 
+      13 : [ [3,2], [4,2], [2,1] ], 
+      14 : [ [4,2], [4,2], [2,1] ], 
+      15 : [ [3,2], [3,2], [3,1] ], 
+      16 : [ [4,2], [3,2], [3,1] ] }

core/leras/nn.py

@@ -46,6 +46,7 @@ class nn():
     # Tensor ops
     tf_get_value = None
     tf_batch_set_value = None
+    tf_init_weights = None
     tf_gradients = None
     tf_average_gv_list = None
     tf_average_tensor_list = None
@@ -78,6 +79,9 @@ class nn():
     # Optimizers
     TFBaseOptimizer = None
     TFRMSpropOptimizer = None
+    
+    # Models
+    PatchDiscriminator = None
 
     @staticmethod
     def initialize(device_config=None, floatx="float32", data_format="NHWC"):
@@ -138,11 +142,13 @@ class nn():
             from .layers import initialize_layers
             from .initializers import initialize_initializers
             from .optimizers import initialize_optimizers
+            from .models import initialize_models
 
             initialize_tensor_ops(nn)
             initialize_layers(nn)
             initialize_initializers(nn)
             initialize_optimizers(nn)
+            initialize_models(nn)
 
         if nn.tf_sess is None:
             nn.tf_sess = tf.Session(config=nn.tf_sess_config)

core/leras/tensor_ops.py

@@ -29,7 +29,28 @@ def initialize_tensor_ops(nn):
                 nn.tf_sess.run(assign_ops, feed_dict=feed_dict)
     nn.tf_batch_set_value = tf_batch_set_value
 
+    def tf_init_weights(weights):
+        ops = []
 
+        ca_tuples_w = []
+        ca_tuples = []
+        for w in weights:
+            initializer = w.initializer
+            for input in initializer.inputs:
+                if "_cai_" in input.name:
+                    ca_tuples_w.append (w)
+                    ca_tuples.append ( (w.shape.as_list(), w.dtype.as_numpy_dtype) )
+                    break
+            else:
+                ops.append (initializer)
+
+        if len(ops) != 0:
+            nn.tf_sess.run (ops)
+
+        if len(ca_tuples) != 0:
+            nn.tf_batch_set_value( [*zip(ca_tuples_w, nn.initializers.ca.generate_batch (ca_tuples))] )
+    nn.tf_init_weights = tf_init_weights
+    
     def tf_gradients ( loss, vars ):
         grads = gradients.gradients(loss, vars, colocate_gradients_with_ops=True )
         gv = [*zip(grads,vars)]