nn_ops.bias_add, tf.layers.batch_normalization

Author: Oceania2018

src/TensorFlowNET.Core/APIs/tf.array.cs

@@ -19,5 +19,16 @@ public static partial class tf
         /// </returns>
         public static Tensor expand_dims(Tensor input, int axis = -1, string name = null, int dim = -1)
             => array_ops.expand_dims(input, axis, name, dim);
+
+        /// <summary>
+        /// Transposes `a`. Permutes the dimensions according to `perm`.
+        /// </summary>
+        /// <param name="a"></param>
+        /// <param name="perm"></param>
+        /// <param name="name"></param>
+        /// <param name="conjugate"></param>
+        /// <returns></returns>
+        public static Tensor transpose(Tensor a, int[] perm = null, string name = "transpose", bool conjugate = false)
+            => array_ops.transpose(a, perm, name, conjugate);
     }
 }

src/TensorFlowNET.Core/APIs/tf.layers.cs

@@ -46,6 +46,45 @@ public static Tensor conv2d(Tensor inputs,
 
                 return layer.apply(inputs);
             }
+
+            /// <summary>
+            /// Functional interface for the batch normalization layer.
+            /// http://arxiv.org/abs/1502.03167
+            /// </summary>
+            /// <param name="inputs"></param>
+            /// <param name="axis"></param>
+            /// <param name="momentum"></param>
+            /// <param name="epsilon"></param>
+            /// <param name="center"></param>
+            /// <param name="scale"></param>
+            /// <param name="beta_initializer"></param>
+            /// <param name="gamma_initializer"></param>
+            /// <param name="moving_mean_initializer"></param>
+            /// <param name="moving_variance_initializer"></param>
+            /// <param name="training"></param>
+            /// <param name="trainable"></param>
+            /// <param name="name"></param>
+            /// <param name="renorm"></param>
+            /// <param name="renorm_momentum"></param>
+            /// <returns></returns>
+            public static Tensor batch_normalization(Tensor inputs,
+                int axis = -1,
+                float momentum = 0.99f,
+                float epsilon = 0.001f,
+                bool center = true,
+                bool scale = true,
+                IInitializer beta_initializer = null,
+                IInitializer gamma_initializer = null,
+                IInitializer moving_mean_initializer = null,
+                IInitializer moving_variance_initializer = null,
+                Tensor training = null,
+                bool trainable = true,
+                string name = null,
+                bool renorm = false,
+                float renorm_momentum = 0.99f)
+            {
+                throw new NotImplementedException("batch_normalization");
+            }
         }
     }
 }

src/TensorFlowNET.Core/Keras/Engine/Layer.cs

@@ -30,6 +30,7 @@ public Tensor __call__(Tensor inputs,
             VariableScope scope = null)
         {
             var input_list = new Tensor[] { inputs };
+            Tensor outputs = null;
 
             // We will attempt to build a TF graph if & only if all inputs are symbolic.
             // This is always the case in graph mode. It can also be the case in eager
@@ -45,9 +46,42 @@ public Tensor __call__(Tensor inputs,
                     _maybe_build(inputs);
                     built = true;
                 }
+
+                if (build_graph)
+                {
+                    // Symbolic execution on symbolic tensors. We will attempt to build
+                    // the corresponding TF subgraph inside `backend.get_graph()`
+                    var graph = backend.get_graph();
+                    outputs = call(inputs);
+                    _handle_activity_regularization(inputs, outputs);
+                    _set_mask_metadata(inputs, outputs, null);
+                }
             });
 
-            throw new NotImplementedException("");
+            return outputs;
+        }
+
+        private void _handle_activity_regularization(Tensor inputs, Tensor outputs)
+        {
+            //if(_activity_regularizer != null)
+            {
+
+            }
+        }
+
+        private void _set_mask_metadata(Tensor inputs, Tensor outputs, Tensor previous_mask)
+        {
+
+        }
+
+        private Tensor compute_mask(Tensor inputs, Tensor mask = null)
+        {
+            return null;
+        }
+
+        protected virtual Tensor call(Tensor inputs)
+        {
+            throw new NotImplementedException("Layer.call");
         }
 
         protected virtual string _name_scope()

src/TensorFlowNET.Core/Keras/Layers/Conv.cs

@@ -90,5 +90,26 @@ protected override void build(TensorShape input_shape)
 
             built = true;
         }
+
+        protected override Tensor call(Tensor inputs)
+        {
+            var outputs = _convolution_op.__call__(inputs, kernel);
+            if (use_bias)
+            {
+                if (data_format == "channels_first")
+                {
+                    throw new NotImplementedException("call channels_first");
+                }
+                else
+                {
+                    outputs = nn_ops.bias_add(outputs, bias, data_format: "NHWC");
+                }
+            }
+
+            if (activation != null)
+                return activation.Activate(outputs);
+
+            return outputs;
+        }
     }
 }

src/TensorFlowNET.Core/Keras/backend.cs

@@ -10,5 +10,10 @@ public static void track_variable(RefVariable v)
         {
 
         }
+
+        public static Graph get_graph()
+        {
+            return ops.get_default_graph();
+        }
     }
 }

src/TensorFlowNET.Core/Layers/Layer.cs

@@ -65,7 +65,10 @@ public Tensor __call__(Tensor inputs,
             // Actually call layer
             var outputs = base.__call__(inputs);
 
-            throw new NotImplementedException("");
+            // Update global default collections.
+            //_add_elements_to_collection(updates, ops.GraphKeys.UPDATE_OPS);
+
+            return outputs;
         }
 
         protected virtual RefVariable add_weight(string name,

src/TensorFlowNET.Core/Operations/Activation/IActivation.cs

@@ -6,6 +6,6 @@ namespace Tensorflow.Operations.Activation
 {
     public interface IActivation
     {
-
+        Tensor Activate(Tensor features, string name = null);
     }
 }

src/TensorFlowNET.Core/Operations/Activation/gen_nn_ops.py.cs

@@ -6,6 +6,16 @@ namespace Tensorflow.Operations.Activation
 {
     public class relu : IActivation
     {
+        public Tensor Activate(Tensor features, string name = null)
+        {
+            OpDefLibrary _op_def_lib = new OpDefLibrary();
 
+            var _op = _op_def_lib._apply_op_helper("Relu", name: name, args: new
+            {
+                features
+            });
+
+            return _op.outputs[0];
+        }
     }
 }

src/TensorFlowNET.Core/Operations/NnOps/Convolution.cs

@@ -62,5 +62,10 @@ public _NonAtrousConvolution _build_op(int _, string padding)
                 strides: strides,
                 name: name);
         }
+
+        public Tensor __call__(Tensor inp, RefVariable filter)
+        {
+            return conv_op.__call__(inp, filter);
+        }
     }
 }

src/TensorFlowNET.Core/Operations/NnOps/_NonAtrousConvolution.cs

@@ -52,5 +52,18 @@ public _NonAtrousConvolution(TensorShape input_shape,
                 throw new NotImplementedException("_NonAtrousConvolution conv_dims 3");
             }
         }
+
+        public Tensor __call__(Tensor inp, RefVariable filter)
+        {
+            return conv_op(new
+            {
+                input = inp,
+                filter,
+                strides,
+                padding,
+                data_format,
+                name
+            });
+        }
     }
 }