Use tensor.Id instead of GetHashCode.

Oceania2018 · Oceania2018 · commit c3dd96b1c77e · 2021-01-17T15:09:04.000-06:00
diff --git a/src/TensorFlowNET.Core/Binding.cs b/src/TensorFlowNET.Core/Binding.cs
@@ -4,7 +4,7 @@ namespace Tensorflow
 {
     public static partial class Binding
     {
-        [DebuggerNonUserCode]
+        [DebuggerHidden]
         public static tensorflow tf { get; } = New<tensorflow>();
 
         /// <summary>
diff --git a/src/TensorFlowNET.Core/Eager/EagerTensor.Creation.cs b/src/TensorFlowNET.Core/Eager/EagerTensor.Creation.cs
@@ -4,7 +4,7 @@
 
 namespace Tensorflow.Eager
 {
-    public partial class EagerTensor : Tensor
+    public partial class EagerTensor
     {
         public EagerTensor() : base(IntPtr.Zero)
         {
@@ -48,8 +48,8 @@ public EagerTensor Resolve()
             if (_handle == IntPtr.Zero)
                 _handle = c_api.TFE_TensorHandleResolve(EagerTensorHandle, tf.Status.Handle);
 
-            //print($"new Tensor {Id} {_handle.ToString("x16")}");
-            //print($"new TensorHandle {Id} {EagerTensorHandle.ToString("x16")}");
+            // print($"New TensorHandle {Id} 0x{_handle.ToString("x16")}");
+            // print($"New EagerTensorHandle {Id} {EagerTensorHandle}");
 
             return this;
         }
@@ -96,14 +96,14 @@ protected override void DisposeManagedResources()
         {
             base.DisposeManagedResources();
 
-            //print($"deleting DeleteTensorHandle {Id} {EagerTensorHandle.ToString("x16")}");
+            // print($"Delete EagerTensorHandle {Id} {EagerTensorHandle}");
             EagerTensorHandle.Dispose();
         }
 
         protected override void DisposeUnmanagedResources(IntPtr handle)
         {
             base.DisposeUnmanagedResources(handle);
-            //print($"deleting DeleteTensorHandle {Id} {_handle.ToString("x16")}");
+            // print($"Delete TensorHandle {Id} 0x{_handle.ToString("x16")}");
         }
     }
 }
diff --git a/src/TensorFlowNET.Keras/Engine/Functional.cs b/src/TensorFlowNET.Keras/Engine/Functional.cs
@@ -23,8 +23,7 @@ public partial class Functional : Model
         List<KerasHistory> _output_coordinates;
         public string[] NetworkNodes { get; set; }
 
-        Dictionary<int, int> tensor_usage_count;
-        public Dictionary<int, int> TensorUsageCount => tensor_usage_count;
+        Dictionary<long, int> tensor_usage_count;
 
         public Functional(Tensors inputs, Tensors outputs, string name = null)
             : base(new ModelArgs
@@ -38,7 +37,7 @@ public Functional(Tensors inputs, Tensors outputs, string name = null)
             _output_layers = new List<ILayer>();
             _input_coordinates = new List<KerasHistory>();
             _output_coordinates = new List<KerasHistory>();
-            tensor_usage_count = new Dictionary<int, int>();
+            tensor_usage_count = new Dictionary<long, int>();
             if (this is Sequential)
                 return;
             _init_graph_network(inputs, outputs);
@@ -116,33 +115,33 @@ void _set_output_names()
 
         void ComputeTensorUsageCount()
         {
-            var available_tensors = inputs.Select(x => x.GetHashCode()).ToList();
+            var available_tensors = inputs.Select(x => x.Id).ToList();
             var depth_keys = NodesByDepth.Keys.OrderBy(x => x).Reverse().Skip(1).ToArray();
             foreach (var depth in depth_keys)
             {
                 foreach (var node in NodesByDepth[depth])
                 {
-                    var input_tensors = node.KerasInputs.Select(x => x.GetHashCode()).ToArray();
+                    var input_tensors = node.KerasInputs.Select(x => x.Id).ToArray();
                     if (input_tensors.issubset(available_tensors))
                     {
                         foreach (var tensor in node.KerasInputs)
                         {
-                            if (!tensor_usage_count.ContainsKey(tensor.GetHashCode()))
-                                tensor_usage_count[tensor.GetHashCode()] = 0;
-                            tensor_usage_count[tensor.GetHashCode()] += 1;
+                            if (!tensor_usage_count.ContainsKey(tensor.Id))
+                                tensor_usage_count[tensor.Id] = 0;
+                            tensor_usage_count[tensor.Id] += 1;
                         }
 
                         foreach (var output_tensor in node.Outputs)
-                            available_tensors.Add(output_tensor.GetHashCode());
+                            available_tensors.Add(output_tensor.Id);
                     }
                 }
             }
 
             foreach (var tensor in outputs)
             {
-                if (!tensor_usage_count.ContainsKey(tensor.GetHashCode()))
-                    tensor_usage_count[tensor.GetHashCode()] = 0;
-                tensor_usage_count[tensor.GetHashCode()] += 1;
+                if (!tensor_usage_count.ContainsKey(tensor.Id))
+                    tensor_usage_count[tensor.Id] = 0;
+                tensor_usage_count[tensor.Id] += 1;
             }
         }
 
@@ -316,12 +315,11 @@ Tensors run_internal_graph(Tensors inputs, bool training = false, Tensors mask =
                     input_t.KerasMask = masks[i];
             }
 
-            var tensor_dict = new Dictionary<int, Queue<Tensor>>();
+            var tensor_dict = new Dictionary<long, Queue<Tensor>>();
             foreach (var (x, y) in zip(this.inputs, inputs))
             {
                 var y1 = conform_to_reference_input(y, x);
-                var x_id = x.GetHashCode();
-                tensor_dict[x_id] = new Queue<Tensor>(Enumerable.Range(0, tensor_usage_count[x_id]).Select(x => y1));
+                tensor_dict[x.Id] = new Queue<Tensor>(Enumerable.Range(0, tensor_usage_count[x.Id]).Select(x => y1));
             }
 
             var depth_keys = NodesByDepth.Keys.OrderBy(x => x).Reverse().ToArray();
@@ -347,13 +345,10 @@ Tensors run_internal_graph(Tensors inputs, bool training = false, Tensors mask =
                 }
             }
 
-            var output_tensors = new List<Tensor>();
+            var output_tensors = new Tensors();
 
             foreach (var x in outputs)
-            {
-                var x_id = x.GetHashCode();
-                output_tensors.append(tensor_dict[x_id].Dequeue());
-            }
+                output_tensors.Add(tensor_dict[x.Id].Dequeue());
 
             return output_tensors;
         }
diff --git a/src/TensorFlowNET.Keras/Engine/Node.cs b/src/TensorFlowNET.Keras/Engine/Node.cs
@@ -42,10 +42,10 @@ public partial class Node : INode
         public List<Tensor> KerasInputs { get; set; } = new List<Tensor>();
         public ILayer Layer { get; set; }
         public bool is_input => args.InputTensors == null;
-        public int[] FlatInputIds { get; set; }
-        public int[] FlatOutputIds { get; set; }
+        public long[] FlatInputIds { get; set; }
+        public long[] FlatOutputIds { get; set; }
         bool _single_positional_tensor_passed => KerasInputs.Count() == 1;
-        Dictionary<int, int> _keras_inputs_ids_and_indices = new Dictionary<int, int>();
+        Dictionary<int, long> _keras_inputs_ids_and_indices = new Dictionary<int, long>();
         public INode[] ParentNodes
         {
             get
@@ -70,7 +70,7 @@ public Node(Layer layer, NodeArgs args)
                 KerasInputs.AddRange(args.InputTensors);
 
             foreach (var (i, ele) in enumerate(KerasInputs))
-                _keras_inputs_ids_and_indices[i] = ele.GetHashCode();
+                _keras_inputs_ids_and_indices[i] = ele.Id;
 
             // Wire up Node to Layers.
             layer.InboundNodes.Add(this);
@@ -89,16 +89,16 @@ public Node(Layer layer, NodeArgs args)
                 tensor.KerasHistory = new KerasHistory(layer, node_index, i, tensor);
 
             // Cached for performance.
-            FlatInputIds = KerasInputs.Select(x => x.GetHashCode()).ToArray();
-            FlatOutputIds = Outputs.Select(x => x.GetHashCode()).ToArray();
+            FlatInputIds = KerasInputs.Select(x => x.Id).ToArray();
+            FlatOutputIds = Outputs.Select(x => x.Id).ToArray();
         }
 
         /// <summary>
         /// Maps Keras Tensors to computed Tensors using `tensor_dict`.
         /// </summary>
         /// <param name="tensor_dict"></param>
         /// <returns></returns>
-        public Tensors MapArguments(Dictionary<int, Queue<Tensor>> tensor_dict)
+        public Tensors MapArguments(Dictionary<long, Queue<Tensor>> tensor_dict)
         {
             if (_single_positional_tensor_passed)
             {

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ namespace Tensorflow`
`4`	`4`	`{`
`5`	`5`	`public static partial class Binding`
`6`	`6`	`{`
`7`		`- [DebuggerNonUserCode]`
	`7`	`+ [DebuggerHidden]`
`8`	`8`	`public static tensorflow tf { get; } = New<tensorflow>();`
`9`	`9`
`10`	`10`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace Tensorflow.Eager`
`6`	`6`	`{`
`7`		`- public partial class EagerTensor : Tensor`
	`7`	`+ public partial class EagerTensor`
`8`	`8`	`{`
`9`	`9`	`public EagerTensor() : base(IntPtr.Zero)`
`10`	`10`	`{`
`@@ -48,8 +48,8 @@ public EagerTensor Resolve()`
`48`	`48`	`if (_handle == IntPtr.Zero)`
`49`	`49`	`_handle = c_api.TFE_TensorHandleResolve(EagerTensorHandle, tf.Status.Handle);`
`50`	`50`
`51`		`- //print($"new Tensor {Id} {_handle.ToString("x16")}");`
`52`		`- //print($"new TensorHandle {Id} {EagerTensorHandle.ToString("x16")}");`
	`51`	`+ // print($"New TensorHandle {Id} 0x{_handle.ToString("x16")}");`
	`52`	`+ // print($"New EagerTensorHandle {Id} {EagerTensorHandle}");`
`53`	`53`
`54`	`54`	`return this;`
`55`	`55`	`}`
`@@ -96,14 +96,14 @@ protected override void DisposeManagedResources()`
`96`	`96`	`{`
`97`	`97`	`base.DisposeManagedResources();`
`98`	`98`
`99`		`- //print($"deleting DeleteTensorHandle {Id} {EagerTensorHandle.ToString("x16")}");`
	`99`	`+ // print($"Delete EagerTensorHandle {Id} {EagerTensorHandle}");`
`100`	`100`	`EagerTensorHandle.Dispose();`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`protected override void DisposeUnmanagedResources(IntPtr handle)`
`104`	`104`	`{`
`105`	`105`	`base.DisposeUnmanagedResources(handle);`
`106`		`- //print($"deleting DeleteTensorHandle {Id} {_handle.ToString("x16")}");`
	`106`	`+ // print($"Delete TensorHandle {Id} 0x{_handle.ToString("x16")}");`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,7 @@ public partial class Functional : Model`
`23`	`23`	`List<KerasHistory> _output_coordinates;`
`24`	`24`	`public string[] NetworkNodes { get; set; }`
`25`	`25`
`26`		`- Dictionary<int, int> tensor_usage_count;`
`27`		`- public Dictionary<int, int> TensorUsageCount => tensor_usage_count;`
	`26`	`+ Dictionary<long, int> tensor_usage_count;`
`28`	`27`
`29`	`28`	`public Functional(Tensors inputs, Tensors outputs, string name = null)`
`30`	`29`	`: base(new ModelArgs`
`@@ -38,7 +37,7 @@ public Functional(Tensors inputs, Tensors outputs, string name = null)`
`38`	`37`	`_output_layers = new List<ILayer>();`
`39`	`38`	`_input_coordinates = new List<KerasHistory>();`
`40`	`39`	`_output_coordinates = new List<KerasHistory>();`
`41`		`- tensor_usage_count = new Dictionary<int, int>();`
	`40`	`+ tensor_usage_count = new Dictionary<long, int>();`
`42`	`41`	`if (this is Sequential)`
`43`	`42`	`return;`
`44`	`43`	`_init_graph_network(inputs, outputs);`
`@@ -116,33 +115,33 @@ void _set_output_names()`
`116`	`115`
`117`	`116`	`void ComputeTensorUsageCount()`
`118`	`117`	`{`
`119`		`- var available_tensors = inputs.Select(x => x.GetHashCode()).ToList();`
	`118`	`+ var available_tensors = inputs.Select(x => x.Id).ToList();`
`120`	`119`	`var depth_keys = NodesByDepth.Keys.OrderBy(x => x).Reverse().Skip(1).ToArray();`
`121`	`120`	`foreach (var depth in depth_keys)`
`122`	`121`	`{`
`123`	`122`	`foreach (var node in NodesByDepth[depth])`
`124`	`123`	`{`
`125`		`- var input_tensors = node.KerasInputs.Select(x => x.GetHashCode()).ToArray();`
	`124`	`+ var input_tensors = node.KerasInputs.Select(x => x.Id).ToArray();`
`126`	`125`	`if (input_tensors.issubset(available_tensors))`
`127`	`126`	`{`
`128`	`127`	`foreach (var tensor in node.KerasInputs)`
`129`	`128`	`{`
`130`		`- if (!tensor_usage_count.ContainsKey(tensor.GetHashCode()))`
`131`		`- tensor_usage_count[tensor.GetHashCode()] = 0;`
`132`		`- tensor_usage_count[tensor.GetHashCode()] += 1;`
	`129`	`+ if (!tensor_usage_count.ContainsKey(tensor.Id))`
	`130`	`+ tensor_usage_count[tensor.Id] = 0;`
	`131`	`+ tensor_usage_count[tensor.Id] += 1;`
`133`	`132`	`}`
`134`	`133`
`135`	`134`	`foreach (var output_tensor in node.Outputs)`
`136`		`- available_tensors.Add(output_tensor.GetHashCode());`
	`135`	`+ available_tensors.Add(output_tensor.Id);`
`137`	`136`	`}`
`138`	`137`	`}`
`139`	`138`	`}`
`140`	`139`
`141`	`140`	`foreach (var tensor in outputs)`
`142`	`141`	`{`
`143`		`- if (!tensor_usage_count.ContainsKey(tensor.GetHashCode()))`
`144`		`- tensor_usage_count[tensor.GetHashCode()] = 0;`
`145`		`- tensor_usage_count[tensor.GetHashCode()] += 1;`
	`142`	`+ if (!tensor_usage_count.ContainsKey(tensor.Id))`
	`143`	`+ tensor_usage_count[tensor.Id] = 0;`
	`144`	`+ tensor_usage_count[tensor.Id] += 1;`
`146`	`145`	`}`
`147`	`146`	`}`
`148`	`147`
`@@ -316,12 +315,11 @@ Tensors run_internal_graph(Tensors inputs, bool training = false, Tensors mask =`
`316`	`315`	`input_t.KerasMask = masks[i];`
`317`	`316`	`}`
`318`	`317`
`319`		`- var tensor_dict = new Dictionary<int, Queue<Tensor>>();`
	`318`	`+ var tensor_dict = new Dictionary<long, Queue<Tensor>>();`
`320`	`319`	`foreach (var (x, y) in zip(this.inputs, inputs))`
`321`	`320`	`{`
`322`	`321`	`var y1 = conform_to_reference_input(y, x);`
`323`		`- var x_id = x.GetHashCode();`
`324`		`- tensor_dict[x_id] = new Queue<Tensor>(Enumerable.Range(0, tensor_usage_count[x_id]).Select(x => y1));`
	`322`	`+ tensor_dict[x.Id] = new Queue<Tensor>(Enumerable.Range(0, tensor_usage_count[x.Id]).Select(x => y1));`
`325`	`323`	`}`
`326`	`324`
`327`	`325`	`var depth_keys = NodesByDepth.Keys.OrderBy(x => x).Reverse().ToArray();`
`@@ -347,13 +345,10 @@ Tensors run_internal_graph(Tensors inputs, bool training = false, Tensors mask =`
`347`	`345`	`}`
`348`	`346`	`}`
`349`	`347`
`350`		`- var output_tensors = new List<Tensor>();`
	`348`	`+ var output_tensors = new Tensors();`
`351`	`349`
`352`	`350`	`foreach (var x in outputs)`
`353`		`- {`
`354`		`- var x_id = x.GetHashCode();`
`355`		`- output_tensors.append(tensor_dict[x_id].Dequeue());`
`356`		`- }`
	`351`	`+ output_tensors.Add(tensor_dict[x.Id].Dequeue());`
`357`	`352`
`358`	`353`	`return output_tensors;`
`359`	`354`	`}`