Fix Model.build.

Oceania2018 · Oceania2018 · commit 321ddfc13ec7 · 2023-01-15T21:18:05.000-06:00
diff --git a/src/TensorFlowNET.Console/SimpleRnnTest.cs b/src/TensorFlowNET.Console/SimpleRnnTest.cs
@@ -12,20 +12,16 @@ public class SimpleRnnTest
     {
         public void Run()
         {
-            tf.keras = new KerasInterface();
-            var inputs = np.random.random((32, 10, 8)).astype(np.float32);
-            var simple_rnn = tf.keras.layers.SimpleRNN(4);
-            var output = simple_rnn.Apply(inputs);  // The output has shape `[32, 4]`.
-            if (output.shape == (32, 4))
-            {
+            tf.UseKeras<KerasInterface>();
+            var inputs = np.random.random((6, 10, 8)).astype(np.float32);
+            //var simple_rnn = tf.keras.layers.SimpleRNN(4);
+            //var output = simple_rnn.Apply(inputs);  // The output has shape `[32, 4]`.
 
-            }
-            /*simple_rnn = tf.keras.layers.SimpleRNN(
-                4, return_sequences = True, return_state = True)
+            var simple_rnn = tf.keras.layers.SimpleRNN(4, return_sequences: true, return_state: true);
 
-            # whole_sequence_output has shape `[32, 10, 4]`.
-            # final_state has shape `[32, 4]`.
-            whole_sequence_output, final_state = simple_rnn(inputs)*/
+            // whole_sequence_output has shape `[32, 10, 4]`.
+            // final_state has shape `[32, 4]`.
+            var (whole_sequence_output, final_state) = simple_rnn.Apply(inputs);
         }
     }
 }
diff --git a/src/TensorFlowNET.Core/Keras/Layers/ILayer.cs b/src/TensorFlowNET.Core/Keras/Layers/ILayer.cs
@@ -9,6 +9,7 @@ public interface ILayer
         string Name { get; }
         bool Trainable { get; }
         bool Built { get; }
+        void build(Shape input_shape);
         List<ILayer> Layers { get; }
         List<INode> InboundNodes { get; }
         List<INode> OutboundNodes { get; }
diff --git a/src/TensorFlowNET.Core/Keras/Layers/ILayersApi.cs b/src/TensorFlowNET.Core/Keras/Layers/ILayersApi.cs
@@ -163,7 +163,9 @@ public ILayer SimpleRNN(int units,
             string activation = "tanh",
             string kernel_initializer = "glorot_uniform",
             string recurrent_initializer = "orthogonal",
-            string bias_initializer = "zeros");
+            string bias_initializer = "zeros",
+            bool return_sequences = false,
+            bool return_state = false);
 
         public ILayer Subtract();
     }
diff --git a/src/TensorFlowNET.Core/Operations/Initializers/Orthogonal.cs b/src/TensorFlowNET.Core/Operations/Initializers/Orthogonal.cs
@@ -1,12 +1,32 @@
 ﻿using System;
+using System.Linq;
+using static Tensorflow.TensorShapeProto.Types;
 
 namespace Tensorflow.Operations.Initializers
 {
     public class Orthogonal : IInitializer
     {
+        float _gain = 0f;
+
+        public Orthogonal(float gain = 1.0f, int? seed = null)
+        {
+
+        }
+
         public Tensor Apply(InitializerArgs args)
         {
-            throw new NotImplementedException();
+            return _generate_init_val(args.Shape, args.DType);
+        }
+
+        private Tensor _generate_init_val(Shape shape, TF_DataType dtype)
+        {
+            var num_rows = 1L;
+            foreach (var dim in shape.dims.Take(shape.ndim - 1))
+                num_rows *= dim;
+            var num_cols = shape.dims.Last();
+            var flat_shape = (Math.Max(num_cols, num_rows), Math.Min(num_cols, num_rows));
+
+            throw new NotImplementedException("");
         }
     }
 }
diff --git a/src/TensorFlowNET.Core/Operations/NnOps/RNNCell.cs b/src/TensorFlowNET.Core/Operations/NnOps/RNNCell.cs
@@ -147,5 +147,10 @@ public LayerArgs get_config()
         {
             throw new NotImplementedException();
         }
+
+        public void build(Shape input_shape)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/src/TensorFlowNET.Core/tensorflow.cs b/src/TensorFlowNET.Core/tensorflow.cs
@@ -65,6 +65,11 @@ public tensorflow()
             InitGradientEnvironment();
         }
 
+        public void UseKeras<T>() where T : IKerasApi, new()
+        {
+            keras = new T();
+        }
+
         public string VERSION => c_api.StringPiece(c_api.TF_Version());
 
         private void InitGradientEnvironment()
diff --git a/src/TensorFlowNET.Keras/Engine/Functional.cs b/src/TensorFlowNET.Keras/Engine/Functional.cs
@@ -65,7 +65,12 @@ protected void _init_graph_network(Tensors inputs, Tensors outputs)
             }
 
             // Keep track of the network's nodes and layers.
-            (NetworkNodes, NodesByDepth, _self_tracked_trackables, _) = MapGraphNetwork(inputs, outputs);
+            (NetworkNodes, NodesByDepth, var layers, _) = MapGraphNetwork(inputs, outputs);
+
+            if (!_self_tracked_trackables.Any())
+            {
+                _self_tracked_trackables = layers;
+            }
 
             // Build self.input_names and self.output_names.
             _set_output_names();
diff --git a/src/TensorFlowNET.Keras/Engine/Model.Build.cs b/src/TensorFlowNET.Keras/Engine/Model.Build.cs
@@ -1,9 +1,6 @@
 ﻿using System;
 using System.Linq;
 using Tensorflow.Graphs;
-using Tensorflow.Keras.ArgsDefinition;
-using Tensorflow.Keras.Losses;
-using Tensorflow.Keras.Optimizers;
 using static Tensorflow.Binding;
 using static Tensorflow.KerasApi;
 
@@ -13,6 +10,12 @@ public partial class Model
     {
         public override void build(Shape input_shape)
         {
+            if (this is Functional || this is Sequential)
+            {
+                base.build(input_shape);
+                return;
+            }
+
             var graph = tf.executing_eagerly() ? new FuncGraph("build_graph") : keras.backend.get_graph();
 
             graph.as_default();
diff --git a/src/TensorFlowNET.Keras/Engine/Sequential.cs b/src/TensorFlowNET.Keras/Engine/Sequential.cs
@@ -122,15 +122,9 @@ public void add(ILayer layer)
             else
             {
                 _self_tracked_trackables.add(layer);
-                _handle_deferred_layer_dependencies(layer);
             }
         }
 
-        void _handle_deferred_layer_dependencies(params ILayer[] layers)
-        {
-            _self_tracked_trackables.AddRange(layers);
-        }
-
         protected override Tensors Call(Tensors inputs, Tensor state = null, bool? training = null)
         {
             if (!_has_explicit_input_shape)
@@ -156,7 +150,7 @@ void _build_graph_network_for_inferred_shape(Shape input_shape, TF_DataType inpu
             ops.init_scope();
             var inputs = keras.Input(batch_input_shape: input_shape,
                 dtype: input_dtype,
-                name: $"{_self_tracked_trackables[0].Name}_input");
+                name: _self_tracked_trackables[0].Name.EndsWith("_input") ? _self_tracked_trackables[0].Name : $"{_self_tracked_trackables[0].Name}_input");
             Tensors layer_input = inputs;
             Tensors layer_output = null;
             Tensors outputs = null;
diff --git a/src/TensorFlowNET.Keras/Layers/LayersApi.cs b/src/TensorFlowNET.Keras/Layers/LayersApi.cs
@@ -658,14 +658,18 @@ public ILayer SimpleRNN(int units,
             string activation = "tanh",
             string kernel_initializer = "glorot_uniform",
             string recurrent_initializer = "orthogonal",
-            string bias_initializer = "zeros")
+            string bias_initializer = "zeros",
+            bool return_sequences = false,
+            bool return_state = false)
                 => new SimpleRNN(new SimpleRNNArgs
                 {
                     Units = units,
                     Activation = GetActivationByName(activation),
                     KernelInitializer = GetInitializerByName(kernel_initializer),
-                    RecurrentInitializer= GetInitializerByName(recurrent_initializer),
-                    BiasInitializer= GetInitializerByName(bias_initializer)
+                    RecurrentInitializer = GetInitializerByName(recurrent_initializer),
+                    BiasInitializer = GetInitializerByName(bias_initializer),
+                    ReturnSequences = return_sequences,
+                    ReturnState = return_state
                 });
 
         /// <summary>
diff --git a/src/TensorFlowNET.Keras/Layers/Rnn/RNN.cs b/src/TensorFlowNET.Keras/Layers/Rnn/RNN.cs
@@ -18,7 +18,7 @@ public class RNN : Layer
         private int _num_constants = 0;
         protected IVariableV1 kernel;
         protected IVariableV1 bias;
-
+        protected ILayer cell;
         public RNN(RNNArgs args) : base(PreConstruct(args))
         {
             this.args = args;
@@ -37,6 +37,14 @@ public RNN(RNNArgs args) : base(PreConstruct(args))
             //}
         }
 
+        public override void build(Shape input_shape)
+        {
+            if (!cell.Built)
+            {
+                cell.build(input_shape);
+            }
+        }
+
         private static RNNArgs PreConstruct(RNNArgs args)
         {
             if (args.Kwargs == null)
diff --git a/src/TensorFlowNET.Keras/Layers/Rnn/SimpleRNN.cs b/src/TensorFlowNET.Keras/Layers/Rnn/SimpleRNN.cs
@@ -9,22 +9,10 @@ namespace Tensorflow.Keras.Layers.Rnn
     public class SimpleRNN : RNN
     {
         SimpleRNNArgs args;
-        SimpleRNNCell cell;
         public SimpleRNN(SimpleRNNArgs args) : base(args)
         {
             this.args = args;
-        }
-
-        public override void build(Shape input_shape)
-        {
-            var input_dim = input_shape[-1];
-
-            kernel = add_weight("kernel", (input_shape[-1], args.Units),
-                initializer: args.KernelInitializer
-                //regularizer = self.kernel_regularizer,
-                //constraint = self.kernel_constraint,
-                //caching_device = default_caching_device,
-            );
+            cell = new SimpleRNNCell(args);
         }
     }
 }
diff --git a/src/TensorFlowNET.Keras/Layers/Rnn/SimpleRNNCell.cs b/src/TensorFlowNET.Keras/Layers/Rnn/SimpleRNNCell.cs
@@ -8,14 +8,36 @@ namespace Tensorflow.Keras.Layers.Rnn
 {
     public class SimpleRNNCell : Layer
     {
+        SimpleRNNArgs args;
+        IVariableV1 kernel;
+        IVariableV1 recurrent_kernel;
+        IVariableV1 bias;
+
         public SimpleRNNCell(SimpleRNNArgs args) : base(args)
         {
-
+            this.args = args;
         }
 
         public override void build(Shape input_shape)
         {
-            
+            var input_dim = input_shape[-1];
+
+            kernel = add_weight("kernel", (input_shape[-1], args.Units),
+                initializer: args.KernelInitializer
+            );
+
+            recurrent_kernel = add_weight("recurrent_kernel", (args.Units, args.Units),
+                initializer: args.RecurrentInitializer
+            );
+
+            if (args.UseBias)
+            {
+                bias = add_weight("bias", (args.Units),
+                    initializer: args.RecurrentInitializer
+                );
+            }
+
+            built = true;
         }
     }
 }
diff --git a/test/TensorFlowNET.Keras.UnitTest/Layers/LayersTest.cs b/test/TensorFlowNET.Keras.UnitTest/Layers/LayersTest.cs
@@ -150,10 +150,13 @@ public void EinsumDense()
         [TestMethod]
         public void SimpleRNN()
         {
-            var inputs = np.random.random((32, 10, 8)).astype(np.float32);
-            var simple_rnn = keras.layers.SimpleRNN(4);
+            tf.UseKeras<KerasInterface>();
+            var inputs = np.arange(6 * 10 * 8).reshape((6, 10, 8)).astype(np.float32);
+            /*var simple_rnn = keras.layers.SimpleRNN(4);
             var output = simple_rnn.Apply(inputs);
-            Assert.AreEqual((32, 4), output.shape);
+            Assert.AreEqual((32, 4), output.shape);*/
+            var simple_rnn = tf.keras.layers.SimpleRNN(4, return_sequences: true, return_state: true);
+            var (whole_sequence_output, final_state) = simple_rnn.Apply(inputs);
         }
 
         [TestMethod]
diff --git a/test/TensorFlowNET.UnitTest/Tensorflow.Binding.UnitTest.csproj b/test/TensorFlowNET.UnitTest/Tensorflow.Binding.UnitTest.csproj
@@ -47,7 +47,7 @@
 
   <ItemGroup>
     <PackageReference Include="FluentAssertions" Version="5.10.3" />
-    <PackageReference Include="MethodBoundaryAspect.Fody" Version="2.0.144" />
+    <PackageReference Include="MethodBoundaryAspect.Fody" Version="2.0.148" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
     <PackageReference Include="MSTest.TestAdapter" Version="2.2.8" />
     <PackageReference Include="MSTest.TestFramework" Version="2.2.8" />

Original file line number	Diff line number	Diff line change
`@@ -12,20 +12,16 @@ public class SimpleRnnTest`
`12`	`12`	`{`
`13`	`13`	`public void Run()`
`14`	`14`	`{`
`15`		`- tf.keras = new KerasInterface();`
`16`		`- var inputs = np.random.random((32, 10, 8)).astype(np.float32);`
`17`		`- var simple_rnn = tf.keras.layers.SimpleRNN(4);`
`18`		- var output = simple_rnn.Apply(inputs); // The output has shape `[32, 4]`.
`19`		`- if (output.shape == (32, 4))`
`20`		`- {`
	`15`	`+ tf.UseKeras<KerasInterface>();`
	`16`	`+ var inputs = np.random.random((6, 10, 8)).astype(np.float32);`
	`17`	`+ //var simple_rnn = tf.keras.layers.SimpleRNN(4);`
	`18`	+ //var output = simple_rnn.Apply(inputs); // The output has shape `[32, 4]`.
`21`	`19`
`22`		`- }`
`23`		`- /*simple_rnn = tf.keras.layers.SimpleRNN(`
`24`		`- 4, return_sequences = True, return_state = True)`
	`20`	`+ var simple_rnn = tf.keras.layers.SimpleRNN(4, return_sequences: true, return_state: true);`
`25`	`21`
`26`		- # whole_sequence_output has shape `[32, 10, 4]`.
`27`		- # final_state has shape `[32, 4]`.
`28`		`- whole_sequence_output, final_state = simple_rnn(inputs)*/`
	`22`	+ // whole_sequence_output has shape `[32, 10, 4]`.
	`23`	+ // final_state has shape `[32, 4]`.
	`24`	`+ var (whole_sequence_output, final_state) = simple_rnn.Apply(inputs);`
`29`	`25`	`}`
`30`	`26`	`}`
`31`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,32 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Linq;`
	`3`	`+using static Tensorflow.TensorShapeProto.Types;`
`2`	`4`
`3`	`5`	`namespace Tensorflow.Operations.Initializers`
`4`	`6`	`{`
`5`	`7`	`public class Orthogonal : IInitializer`
`6`	`8`	`{`
	`9`	`+ float _gain = 0f;`
	`10`	`+`
	`11`	`+ public Orthogonal(float gain = 1.0f, int? seed = null)`
	`12`	`+ {`
	`13`	`+`
	`14`	`+ }`
	`15`	`+`
`7`	`16`	`public Tensor Apply(InitializerArgs args)`
`8`	`17`	`{`
`9`		`- throw new NotImplementedException();`
	`18`	`+ return _generate_init_val(args.Shape, args.DType);`
	`19`	`+ }`
	`20`	`+`
	`21`	`+ private Tensor _generate_init_val(Shape shape, TF_DataType dtype)`
	`22`	`+ {`
	`23`	`+ var num_rows = 1L;`
	`24`	`+ foreach (var dim in shape.dims.Take(shape.ndim - 1))`
	`25`	`+ num_rows *= dim;`
	`26`	`+ var num_cols = shape.dims.Last();`
	`27`	`+ var flat_shape = (Math.Max(num_cols, num_rows), Math.Min(num_cols, num_rows));`
	`28`	`+`
	`29`	`+ throw new NotImplementedException("");`
`10`	`30`	`}`
`11`	`31`	`}`
`12`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -147,5 +147,10 @@ public LayerArgs get_config()`
`147`	`147`	`{`
`148`	`148`	`throw new NotImplementedException();`
`149`	`149`	`}`
	`150`	`+`
	`151`	`+ public void build(Shape input_shape)`
	`152`	`+ {`
	`153`	`+ throw new NotImplementedException();`
	`154`	`+ }`
`150`	`155`	`}`
`151`	`156`	`}`
Original file line number	Diff line number	Diff line change
`@@ -122,15 +122,9 @@ public void add(ILayer layer)`
`122`	`122`	`else`
`123`	`123`	`{`
`124`	`124`	`_self_tracked_trackables.add(layer);`
`125`		`- _handle_deferred_layer_dependencies(layer);`
`126`	`125`	`}`
`127`	`126`	`}`
`128`	`127`
`129`		`- void _handle_deferred_layer_dependencies(params ILayer[] layers)`
`130`		`- {`
`131`		`- _self_tracked_trackables.AddRange(layers);`
`132`		`- }`
`133`		`-`
`134`	`128`	`protected override Tensors Call(Tensors inputs, Tensor state = null, bool? training = null)`
`135`	`129`	`{`
`136`	`130`	`if (!_has_explicit_input_shape)`
`@@ -156,7 +150,7 @@ void _build_graph_network_for_inferred_shape(Shape input_shape, TF_DataType inpu`
`156`	`150`	`ops.init_scope();`
`157`	`151`	`var inputs = keras.Input(batch_input_shape: input_shape,`
`158`	`152`	`dtype: input_dtype,`
`159`		`- name: $"{_self_tracked_trackables[0].Name}_input");`
	`153`	`+ name: _self_tracked_trackables[0].Name.EndsWith("_input") ? _self_tracked_trackables[0].Name : $"{_self_tracked_trackables[0].Name}_input");`
`160`	`154`	`Tensors layer_input = inputs;`
`161`	`155`	`Tensors layer_output = null;`
`162`	`156`	`Tensors outputs = null;`