refactor gradient tape.

Author: Oceania2018

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

@@ -14,22 +14,32 @@ You may obtain a copy of the License at
    limitations under the License.
 ******************************************************************************/
 
+using System.Collections.Generic;
 using Tensorflow.Gradients;
 
 namespace Tensorflow
 {
     public partial class tensorflow
     {
+        GradientTape _tapeSet;
+
         /// <summary>
         /// Record operations for automatic differentiation.
         /// </summary>
         /// <param name="persistent"></param>
         /// <param name="watch_accessed_variables"></param>
-        /// <returns></returns>
+        /// <returns>Tape set</returns>
         public GradientTape GradientTape(bool persistent = false,
             bool watch_accessed_variables = true)
-            => new GradientTape(persistent: persistent,
+        {
+            var tape = _tapeSet.PushTape(persistent: persistent,
                 watch_accessed_variables: watch_accessed_variables);
+            tape.StartRecord();
+            return _tapeSet;
+        }
+
+        public Stack<ITape> GetTapeSet()
+            => _tapeSet.GetTapeSet();
 
         public Tensor[] gradients(Tensor[] ys,
             Tensor[] xs,

src/TensorFlowNET.Core/Binding.cs

@@ -4,7 +4,7 @@ namespace Tensorflow
 {
     public static partial class Binding
     {
-        public static tensorflow tf { get; } = New<tensorflow>();
+        public static tensorflow tf { get; } = new tensorflow();
 
         /// <summary>
         ///     Alias to null, similar to python's None.

src/TensorFlowNET.Core/Eager/EagerRunner.MustRecordGradient.cs

@@ -11,5 +11,19 @@ public bool MustRecordGradient()
         {
             return HasGradientTape();
         }
+
+        private bool ShouldRecord(Tensor[] inputs)
+        {
+            bool should_record = false;
+            foreach (var tape in tf.GetTapeSet())
+            {
+                if (tape.ShouldRecord(inputs))
+                {
+                    should_record = true;
+                    break;
+                }
+            }
+            return should_record;
+        }
     }
 }

src/TensorFlowNET.Core/Eager/EagerRunner.RecordGradient.cs

@@ -2,7 +2,6 @@
 using System.Linq;
 using Tensorflow.Gradients;
 using static Tensorflow.Binding;
-using static Tensorflow.tensorflow;
 
 namespace Tensorflow.Eager
 {
@@ -14,18 +13,7 @@ public bool RecordGradient(string op_name,
             Tensor[] results,
             Func<BackwardFunction> getBackwardFunction = null)
         {
-            var input_ids = MakeTensorIDList(inputs);
-            var input_dtypes = MakeTensorDtypeList(inputs);
-
-            bool should_record = false;
-            foreach (var tape in tf.GetTapeSet())
-            {
-                if (tape.ShouldRecord(input_ids, input_dtypes))
-                {
-                    should_record = true;
-                    break;
-                }
-            }
+            bool should_record = ShouldRecord(inputs);
 
             if (!should_record)
             {
@@ -43,35 +31,27 @@ public bool RecordGradient(string op_name,
             tf.Logger.Debug($"RecordGradient: op_name={op_name}");
 
             Tensor[] op_outputs;
-#pragma warning disable CS0219 // Variable is assigned but its value is never used
-            bool op_outputs_tuple_created = false;
-#pragma warning restore CS0219 // Variable is assigned but its value is never used
             var unused_output_indices = gradient_exclustions.OpGradientUnusedOutputIndices(op_name);
             if (unused_output_indices != null)
             {
                 if (unused_output_indices.Length == 0)
                     op_outputs = new Tensor[0];
                 else
                 {
-                    op_outputs_tuple_created = true;
                     // op_outputs = CopySequenceSettingIndicesToNull(results, *unused_output_indices);
                 }
             }
             else
                 op_outputs = results;
 
             Tensor[] op_inputs;
-#pragma warning disable CS0219 // Variable is assigned but its value is never used
-            bool op_inputs_tuple_created = false;
-#pragma warning restore CS0219 // Variable is assigned but its value is never used
             var unused_input_indices = gradient_exclustions.OpGradientUnusedInputIndices(op_name);
             if (unused_input_indices != null)
             {
                 if (unused_input_indices.Length == 0)
                     op_inputs = new Tensor[0];
                 else
                 {
-                    op_inputs_tuple_created = true;
                     // op_inputs = CopySequenceSettingIndicesToNull(inputs, *unused_input_indices);
                 }
             }
@@ -125,11 +105,6 @@ bool CouldBackprop()
             return HasGradientTape();
         }
 
-        long[] MakeTensorIDList(Tensor[] tensors)
-        {
-            return tensors.Select(x => x.Id).ToArray();
-        }
-
         TF_DataType[] MakeTensorDtypeList(Tensor[] tensors)
         {
             return tensors.Select(x => x.dtype).ToArray();

src/TensorFlowNET.Core/Eager/EagerRunner.TFE_FastPathExecute.cs

@@ -310,7 +310,7 @@ bool SetOpAttrList(Context ctx, SafeOpHandle op,
                 for (int i = 0; i < num_values; ++i)
                 {
                     dims[i] = Marshal.AllocHGlobal(sizeof(long) * values1[i].ndim);
-                    tf.memcpy(dims[i], values1[i].dims.Select(x => (long)x).ToArray(), values1[i].ndim * sizeof(long));
+                    tf.memcpy(dims[i], values1[i].dims, values1[i].ndim * sizeof(long));
                 }
 
                 c_api.TFE_OpSetAttrShapeList(op, key, dims, num_dims, num_values, status.Handle);

src/TensorFlowNET.Core/Eager/EagerRunner.TFE_TapeGradient.cs

@@ -14,18 +14,16 @@ public Tensor[] TFE_TapeGradient(ITape tape,
             Tensor[] sources,
             Tensor[] output_gradients)
         {
-            var target_vec = MakeTensorIDList(target);
-            var sources_vec = MakeTensorIDList(sources);
+            var target_vec = target;
+            var sources_vec = sources;
             var sources_set = sources_vec;
 
             var seq_array = target;
-            var source_tensors_that_are_targets = new UnorderedMap<long, TapeTensor>();
+            var source_tensors_that_are_targets = new UnorderedMap<Tensor, TapeTensor>();
 
             for (int i = 0; i < target.Length; ++i)
             {
-                var target_id = target_vec[i];
-                var tensor = seq_array[i];
-                source_tensors_that_are_targets.Add(target_id, TapeTensorFromTensor(tensor));
+                source_tensors_that_are_targets.Add(target_vec[i], new TapeTensor(seq_array[i]));
             }
 
             if (output_gradients != null)

src/TensorFlowNET.Core/Eager/EagerRunner.TapeSetRecordOperation.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Tensorflow.Gradients;
-using static Tensorflow.tensorflow;
 
 namespace Tensorflow.Eager
 {
@@ -12,16 +12,13 @@ public bool TapeSetRecordOperation(string op_type,
             Tensor[] output_tensors,
             Func<BackwardFunction> backward_function_getter)
         {
-            var output_info = new List<TapeTensor>();
+            var output_info = output_tensors.Select(x => new TapeTensor(x)).ToArray();
 
-            if (!TapeTensorsFromTensorSequence(output_tensors, output_info))
-                return false;
-
-            if (!TapeSetRecordForwardprop(op_type, input_tensors, output_info.ToArray(),
+            if (!TapeSetRecordForwardprop(op_type, input_tensors, output_info,
                     backward_function_getter))
                 return false;
 
-            TapeSetRecordBackprop(op_type, input_tensors, output_info.ToArray(),
+            TapeSetRecordBackprop(op_type, input_tensors, output_info,
                 backward_function_getter);
 
             return true;

src/TensorFlowNET.Core/Eager/EagerRunner.TapeTensorFromTensor.cs

@@ -7,21 +7,21 @@ public class BackpropInitialState
     {
         public OpTape<BackwardFunction, TapeTensor> op_tape { get; set; }
         /// <summary>
-        /// Map from tensor ID to how many references still exist for this tensor in
+        /// Map from tensor to how many references still exist for this tensor in
         /// the tape.
         /// </summary>
-        public UnorderedMap<long, long> tensor_usage_counts { get; set; }
+        public UnorderedMap<Tensor, long> tensor_usage_counts { get; set; }
         /// <summary>
         /// Maps from op ID to how many output tensors of this op still need to have
         /// their gradients computed.
         /// </summary>
-        public UnorderedMap<long, long> op_missing_tensor { get; set; }
+        public UnorderedMap<Tensor, long> op_missing_tensor { get; set; }
 
         public BackpropInitialState()
         {
             op_tape = new OpTape<BackwardFunction, TapeTensor>();
-            tensor_usage_counts = new UnorderedMap<long, long>();
-            op_missing_tensor = new UnorderedMap<long, long>();
+            tensor_usage_counts = new UnorderedMap<Tensor, long>();
+            op_missing_tensor = new UnorderedMap<Tensor, long>();
         }
     }
 }