change ops.name_scope interface.

Oceania2018 · Oceania2018 · commit 8fa1f21e3edc · 2019-03-08T14:01:15.000-06:00
diff --git a/src/TensorFlowNET.Core/Framework/importer.py.cs b/src/TensorFlowNET.Core/Framework/importer.py.cs
@@ -26,7 +26,7 @@ public static ITensorOrOperation[] import_graph_def(GraphDef graph_def,
 
             string prefix = "";
             var graph = ops.get_default_graph();
-            with(new ops.name_scope(name, "import", input_map.Values), scope =>
+            with(ops.name_scope(name, "import", input_map.Values), scope =>
             {
                 prefix = scope;
                 /*if (!string.IsNullOrEmpty(prefix))
diff --git a/src/TensorFlowNET.Core/Framework/tf.ops.cs b/src/TensorFlowNET.Core/Framework/tf.ops.cs
@@ -16,8 +16,8 @@ public static object get_collection(string key, string scope = "") => get_defaul
         /// <param name="default_name">The default name to use if the name argument is None.</param>
         /// <param name="values">The list of Tensor arguments that are passed to the op function.</param>
         /// <returns>The scope name.</returns>
-        public static ops.name_scope name_scope(string name, 
+        public static ops.NameScope name_scope(string name, 
             string default_name = "", 
-            object values = null) => new ops.name_scope(name, default_name, values);
+            object values = null) => new ops.NameScope(name, default_name, values);
     }
 }
diff --git a/src/TensorFlowNET.Core/Gradients/gradients_impl.py.cs b/src/TensorFlowNET.Core/Gradients/gradients_impl.py.cs
@@ -58,7 +58,7 @@ public static Tensor[] _GradientsHelper(Tensor[] ys,
              **/
             var grads = new Dictionary<string, Tensor[][]>();
 
-            with(new ops.name_scope(name, "gradients", values: all), scope =>
+            with(ops.name_scope(name, "gradients", values: all), scope =>
             {
                 string grad_scope = scope;
                 // Get a uid for this call to gradients that can be used to help
@@ -131,7 +131,7 @@ public static Tensor[] _GradientsHelper(Tensor[] ys,
                             // for ops that do not have gradients.
                             var grad_fn = ops.get_gradient_function(op);
 
-                            with(new ops.name_scope(op.name + "_grad"), scope1 =>
+                            with(ops.name_scope(op.name + "_grad"), scope1 =>
                             {
                                 string name1 = scope1;
                                 if (grad_fn != null)
diff --git a/src/TensorFlowNET.Core/Keras/Engine/Layer.cs b/src/TensorFlowNET.Core/Keras/Engine/Layer.cs
@@ -31,7 +31,7 @@ public Tensor __call__(Tensor inputs,
             bool build_graph = tf_utils.are_all_symbolic_tensors(input_list);
 
             // Handle Keras mask propagation from previous layer to current layer.
-            Python.with(new ops.name_scope(_name_scope()), delegate
+            Python.with(ops.name_scope(_name_scope()), delegate
             {
                 if (!built)
                 {
diff --git a/src/TensorFlowNET.Core/Layers/Layer.cs b/src/TensorFlowNET.Core/Layers/Layer.cs
@@ -92,7 +92,7 @@ protected virtual void add_weight()
                 auxiliary_name_scope: false), scope =>
             {
                 _current_scope = scope;
-                Python.with(new ops.name_scope(_name_scope()), delegate
+                Python.with(ops.name_scope(_name_scope()), delegate
                 {
 
 
diff --git a/src/TensorFlowNET.Core/Operations/Distributions/normal.py.cs b/src/TensorFlowNET.Core/Operations/Distributions/normal.py.cs
@@ -33,7 +33,7 @@ public Normal (Tensor loc, Tensor scale, bool validate_args=false, bool allow_na
             parameters.Add("validate_args", validate_args);
             parameters.Add("allow_nan_stats", allow_nan_stats);
 
-            with(new ops.name_scope(name, "", new { loc, scale }), scope => 
+            with(ops.name_scope(name, "", new { loc, scale }), scope => 
             {
                 with(ops.control_dependencies(validate_args ? new Operation[] { scale.op} : new Operation[] { }), cd =>
                 {
diff --git a/src/TensorFlowNET.Core/Operations/Losses/losses_impl.py.cs b/src/TensorFlowNET.Core/Operations/Losses/losses_impl.py.cs
@@ -12,7 +12,7 @@ public Tensor sparse_softmax_cross_entropy(Tensor labels,
             string scope = "",
             string loss_collection= "losses")
         {
-            with(new ops.name_scope(scope,
+            with(ops.name_scope(scope,
                 "sparse_softmax_cross_entropy_loss",
                 (logits, labels, weights)),
                 namescope =>
diff --git a/src/TensorFlowNET.Core/Operations/OpDefLibrary.cs b/src/TensorFlowNET.Core/Operations/OpDefLibrary.cs
@@ -44,7 +44,7 @@ public Operation _apply_op_helper(string op_type_name, string name = null, dynam
             var input_types = new List<TF_DataType>();
             dynamic values = null;
 
-            return with(new ops.name_scope(name), scope =>
+            return with(ops.name_scope(name), scope =>
             {
                 var inferred_from = new Dictionary<string, object>();
                 var base_types = new List<TF_DataType>();
diff --git a/src/TensorFlowNET.Core/Operations/array_ops.py.cs b/src/TensorFlowNET.Core/Operations/array_ops.py.cs
@@ -12,7 +12,7 @@ public class array_ops : Python
         public static Tensor zeros(Shape shape, TF_DataType dtype = TF_DataType.TF_FLOAT, string name = null)
         {
             dtype = dtype.as_base_dtype();
-            return with(new ops.name_scope(name, "zeros", shape), scope =>
+            return with(ops.name_scope(name, "zeros", shape), scope =>
             {
                 name = scope;
                 switch (dtype)
@@ -68,7 +68,7 @@ public static Tensor ones_like<T>(T tensor, TF_DataType dtype = TF_DataType.DtIn
 
         private static Tensor ones_like_impl<T>(T tensor, TF_DataType dtype, string name, bool optimize = true)
         {
-            return with(new ops.name_scope(name, "ones_like", new { tensor }), scope =>
+            return with(ops.name_scope(name, "ones_like", new { tensor }), scope =>
             {
                 name = scope;
                 var tensor1 = ops.convert_to_tensor(tensor, name: "tensor");
@@ -84,7 +84,7 @@ private static Tensor ones_like_impl<T>(T tensor, TF_DataType dtype, string name
         public static Tensor ones(Tensor shape, TF_DataType dtype = TF_DataType.TF_FLOAT, string name = null)
         {
             dtype = dtype.as_base_dtype();
-            return with(new ops.name_scope(name, "ones", new { shape }), scope =>
+            return with(ops.name_scope(name, "ones", new { shape }), scope =>
             {
                 name = scope;
                 var output = gen_array_ops.fill(shape, constant_op.constant(1.0f, dtype: dtype), name: name);
@@ -130,7 +130,7 @@ public static Tensor size(Tensor input, string name = null, bool optimize = true
 
         private static Tensor shape_internal(Tensor input, string name = null, bool optimize = true, TF_DataType out_type = TF_DataType.TF_INT32)
         {
-            return with(new ops.name_scope(name, "Shape", new { input }), scope =>
+            return with(ops.name_scope(name, "Shape", new { input }), scope =>
             {
                 name = scope;
 
@@ -151,7 +151,7 @@ private static Tensor shape_internal(Tensor input, string name = null, bool opti
 
         private static Tensor size_internal(Tensor input, string name = null, bool optimize = true, TF_DataType out_type = TF_DataType.TF_INT32)
         {
-            return with(new ops.name_scope(name, "Size", new Tensor[] { input }), scope =>
+            return with(ops.name_scope(name, "Size", new Tensor[] { input }), scope =>
             {
                 name = scope;
 
@@ -182,7 +182,7 @@ private static Tensor size_internal(Tensor input, string name = null, bool optim
 
         public static Tensor zeros_like(Tensor tensor, TF_DataType dtype = TF_DataType.DtInvalid, string name = null, bool optimize = true)
         {
-            return with(new ops.name_scope(name, "zeros_like", new Tensor[] { tensor }), scope =>
+            return with(ops.name_scope(name, "zeros_like", new Tensor[] { tensor }), scope =>
             {
                 name = scope;
                 tensor = ops.convert_to_tensor(tensor, name: "tensor");
diff --git a/src/TensorFlowNET.Core/Operations/control_flow_ops.py.cs b/src/TensorFlowNET.Core/Operations/control_flow_ops.py.cs
@@ -9,7 +9,7 @@ public class control_flow_ops : Python
     {
         public static Operation group<T>(T[] inputs, string name = null) where T : ITensorOrOperation
         {
-            return with(new ops.name_scope(name, "group_deps", inputs), scope =>
+            return with(ops.name_scope(name, "group_deps", inputs), scope =>
             {
                 name = scope;
 
@@ -83,7 +83,7 @@ private static bool IsLoopExit(Operation op)
 
         public static Tensor[] tuple(Tensor[] tensors, string name = null, Operation[] control_inputs = null)
         {
-            return with(new ops.name_scope(name, "tuple", tensors), scope =>
+            return with(ops.name_scope(name, "tuple", tensors), scope =>
             {
                 name = scope;
                 var gating_ops = tensors.Select(x => x.op).ToList();
@@ -115,7 +115,7 @@ public static Tensor with_dependencies(Operation[] dependencies, Tensor output_t
             values.AddRange(dependencies);
             values.Add(output_tensor);
 
-            return with(new ops.name_scope(name, "control_dependency", values), scope =>
+            return with(ops.name_scope(name, "control_dependency", values), scope =>
             {
                 name = scope;
 
diff --git a/src/TensorFlowNET.Core/Operations/embedding_ops.cs b/src/TensorFlowNET.Core/Operations/embedding_ops.cs
@@ -20,7 +20,7 @@ public static Tensor _embedding_lookup_and_transform(RefVariable @params,
                 string name = null,
                 string max_norm = null)
         {
-            return with(new ops.name_scope(name, "embedding_lookup", new { @params, ids }), scope =>
+            return with(ops.name_scope(name, "embedding_lookup", new { @params, ids }), scope =>
             {
                 name = scope;
                 int np = 1;
diff --git a/src/TensorFlowNET.Core/Operations/math_ops.py.cs b/src/TensorFlowNET.Core/Operations/math_ops.py.cs
@@ -15,7 +15,7 @@ public static Tensor cast(Tensor x, TF_DataType dtype = TF_DataType.DtInvalid, s
             if(base_type == x.dtype)
                 return x;
 
-            return with(new ops.name_scope(name, "Cast", new { x }), scope =>
+            return with(ops.name_scope(name, "Cast", new { x }), scope =>
             {
                 x = ops.convert_to_tensor(x, name: "x");
                 if (x.dtype.as_base_dtype() != base_type)
@@ -166,7 +166,7 @@ public static Tensor range(object start, object limit = null, object delta = nul
             if (delta == null)
                 delta = 1;
 
-            return with(new ops.name_scope(name, "Range", new object[] { start, limit, delta }), scope =>
+            return with(ops.name_scope(name, "Range", new object[] { start, limit, delta }), scope =>
             {
                 name = scope;
                 var start1 = ops.convert_to_tensor(start, name: "start");
@@ -179,15 +179,15 @@ public static Tensor range(object start, object limit = null, object delta = nul
 
         public static Tensor floordiv(Tensor x, Tensor y, string name = null)
         {
-            return with(new ops.name_scope(name, "floordiv", new { x, y }), scope =>
+            return with(ops.name_scope(name, "floordiv", new { x, y }), scope =>
             {
                 return gen_math_ops.floor_div(x, y, scope);
             });
         }
 
         public static Tensor rank_internal(Tensor input, string name = null, bool optimize = true)
         {
-            return with(new ops.name_scope(name, "Rank", new List<Tensor> { input }), scope =>
+            return with(ops.name_scope(name, "Rank", new List<Tensor> { input }), scope =>
             {
                 name = scope;
                 var input_tensor = ops.convert_to_tensor(input);
@@ -207,7 +207,7 @@ public static Tensor matmul(Tensor a, Tensor b,
         {
             Tensor result = null;
 
-            with(new ops.name_scope(name, "MatMul", new Tensor[] { a, b }), scope =>
+            with(ops.name_scope(name, "MatMul", new Tensor[] { a, b }), scope =>
             {
                 name = scope;
 
@@ -237,7 +237,7 @@ public static Tensor conj(Tensor x, string name = null)
             if (dt.is_floating() || dt.is_integer())
                 return x;
 
-            return with(new ops.name_scope(name, "Conj", new List<Tensor> { x }), scope =>
+            return with(ops.name_scope(name, "Conj", new List<Tensor> { x }), scope =>
             {
 
                 return x;
diff --git a/src/TensorFlowNET.Core/Operations/nn_impl.py.cs b/src/TensorFlowNET.Core/Operations/nn_impl.py.cs
@@ -19,7 +19,7 @@ public static (Tensor, Tensor) moments(Tensor x,
             string name = null,
             bool keep_dims = false)
         {
-            return with<ops.name_scope, (Tensor, Tensor)>(new ops.name_scope(name, "moments", new { x, axes }), scope =>
+            return with(ops.name_scope(name, "moments", new { x, axes }), scope =>
             {
                 // The dynamic range of fp16 is too limited to support the collection of
                 // sufficient statistics. As a workaround we simply perform the operations
diff --git a/src/TensorFlowNET.Core/Operations/random_ops.py.cs b/src/TensorFlowNET.Core/Operations/random_ops.py.cs
@@ -23,7 +23,7 @@ public static Tensor random_normal(int[] shape,
             int? seed = null, 
             string name = null)
         {
-            return with(new ops.name_scope(name, "random_normal", new { shape, mean, stddev }), scope =>
+            return with(ops.name_scope(name, "random_normal", new { shape, mean, stddev }), scope =>
             {
                 var shape_tensor = _ShapeTensor(shape);
                 var mean_tensor = ops.convert_to_tensor(mean, dtype: dtype, name: "mean");
@@ -53,7 +53,7 @@ public static Tensor random_uniform(int[] shape,
             int? seed = null, 
             string name = null)
         {
-            return with(new ops.name_scope(name, "random_uniform", new { shape, minval, maxval }), scope =>
+            return with(ops.name_scope(name, "random_uniform", new { shape, minval, maxval }), scope =>
             {
                 name = scope;
                 var tensorShape = _ShapeTensor(shape);
diff --git a/src/TensorFlowNET.Core/Tensors/Tensor.Operators.cs b/src/TensorFlowNET.Core/Tensors/Tensor.Operators.cs
@@ -41,7 +41,7 @@ private static Tensor BinaryOpWrapper<Tx, Ty>(string name, Tx x, Ty y)
             if( y is Tensor tr)
                 dtype = tr.dtype.as_base_dtype();
             
-            var namescope = new ops.name_scope(null, name, new { x, y });
+            var namescope = ops.name_scope(null, name, new { x, y });
             return with(namescope, scope =>
             {
                 Tensor result = null;
diff --git a/src/TensorFlowNET.Core/Train/Optimizer.cs b/src/TensorFlowNET.Core/Train/Optimizer.cs
@@ -87,7 +87,7 @@ public Operation apply_gradients(Tuple<Tensor, RefVariable>[] grads_and_vars, Te
             _create_slots(var_list);
 
             var update_ops = new List<Operation>();
-            return with(new ops.name_scope(name, Name), scope =>
+            return with(ops.name_scope(name, Name), scope =>
             {
                 name = scope;
                 _prepare();
@@ -98,7 +98,7 @@ public Operation apply_gradients(Tuple<Tensor, RefVariable>[] grads_and_vars, Te
                         continue;
 
                     var scope_name = var.op.name;
-                    with(new ops.name_scope("update_" + scope_name), scope2 =>
+                    with(ops.name_scope("update_" + scope_name), scope2 =>
                     {
                         update_ops.Add(processor.update_op(this, grad));
                     });
diff --git a/src/TensorFlowNET.Core/Train/Saving/BaseSaverBuilder.cs b/src/TensorFlowNET.Core/Train/Saving/BaseSaverBuilder.cs
@@ -79,7 +79,7 @@ public virtual SaverDef _build_internal(RefVariable[] names_to_saveables,
             Tensor save_tensor = null;
             Operation restore_op = null;
 
-            return with(new ops.name_scope(name, "save", saveables.Select(x => x.op).ToArray()), scope =>
+            return with(ops.name_scope(name, "save", saveables.Select(x => x.op).ToArray()), scope =>
             {
                 name = scope;
 
diff --git a/src/TensorFlowNET.Core/Variables/RefVariable.Operators.cs b/src/TensorFlowNET.Core/Variables/RefVariable.Operators.cs
@@ -17,7 +17,7 @@ public partial class RefVariable
         private static Tensor op_helper<T>(string default_name, RefVariable x, T y)
         {
             var tensor1 = x.value();
-            return with(new ops.name_scope(null, default_name, new { tensor1, y }), scope => {
+            return with(ops.name_scope(null, default_name, new { tensor1, y }), scope => {
                 var tensor2 = ops.convert_to_tensor(y, tensor1.dtype.as_base_dtype(), "y");
                 return gen_math_ops.add(tensor1, tensor2, scope);
             });
diff --git a/src/TensorFlowNET.Core/Variables/RefVariable.cs b/src/TensorFlowNET.Core/Variables/RefVariable.cs
@@ -118,7 +118,7 @@ private void _init_from_args(object initial_value,
 
             ops.init_scope();
             var values = init_from_fn ? new object[0] : new object[] { initial_value };
-            with(new ops.name_scope(name, "Variable", values), scope =>
+            with(ops.name_scope(name, "Variable", values), scope =>
             {
                 name = scope;
                 if (init_from_fn)
@@ -132,7 +132,7 @@ private void _init_from_args(object initial_value,
                         List = new AttrValue.Types.ListValue()
                     };
                     attr.List.S.Add(ByteString.CopyFromUtf8($"loc:{true_name}"));
-                    with(new ops.name_scope("Initializer"), scope2 =>
+                    with(ops.name_scope("Initializer"), scope2 =>
                     {
                         _initial_value = (initial_value as Func<Tensor>)();
                         _initial_value = ops.convert_to_tensor(_initial_value, name: "initial_value", dtype: dtype);
diff --git a/src/TensorFlowNET.Core/Variables/VariableScope.cs b/src/TensorFlowNET.Core/Variables/VariableScope.cs
@@ -39,7 +39,7 @@ public RefVariable get_variable(_VariableStore var_store,
             VariableAggregation aggregation= VariableAggregation.NONE)
         {
             string full_name = !string.IsNullOrEmpty(this._name) ? this._name + "/" + name : name;
-            return with(new ops.name_scope(null), scope =>
+            return with(ops.name_scope(null), scope =>
             {
                 if (dtype == TF_DataType.DtInvalid)
                     dtype = _dtype;
diff --git a/src/TensorFlowNET.Core/Variables/variable_scope.py.cs b/src/TensorFlowNET.Core/Variables/variable_scope.py.cs
@@ -20,7 +20,7 @@ public class variable_scope : IPython
         private VariableScope _scope;
         private string _default_name;
         private object _values;
-        private ops.name_scope _current_name_scope;
+        private ops.NameScope _current_name_scope;
         private bool _auxiliary_name_scope;
         private PureVariableScope _cached_pure_variable_scope;
         private bool? _reuse;
@@ -68,7 +68,7 @@ public void __enter__()
 
         private VariableScope _enter_scope_uncached()
         {
-            ops.name_scope current_name_scope;
+            ops.NameScope current_name_scope;
             PureVariableScope pure_variable_scope = null;
             VariableScope entered_pure_variable_scope;
 
@@ -82,14 +82,14 @@ private VariableScope _enter_scope_uncached()
                 if(!string.IsNullOrEmpty(name_scope))
                     // Hack to reenter
                     name_scope += "/";
-                current_name_scope = new ops.name_scope(name_scope);
+                current_name_scope = ops.name_scope(name_scope);
             }
 
             if (_name != null || _scope != null)
             {
                 var name_scope = _name == null ? _scope._name.Split('/').Last() : _name;
                 if (name_scope != null || current_name_scope != null)
-                    current_name_scope = new ops.name_scope(name_scope);
+                    current_name_scope = ops.name_scope(name_scope);
                 current_name_scope.__enter__();
                 var current_name_scope_name = current_name_scope;
                 _current_name_scope = current_name_scope;
@@ -106,7 +106,7 @@ private VariableScope _enter_scope_uncached()
             }
             else
             {
-                current_name_scope = new ops.name_scope(_default_name);
+                current_name_scope = ops.name_scope(_default_name);
                 current_name_scope.__enter__();
                 string current_name_scope_name = current_name_scope;
                 _current_name_scope = current_name_scope;
diff --git a/src/TensorFlowNET.Core/ops.name_scope.cs b/src/TensorFlowNET.Core/ops.name_scope.cs
diff --git a/test/TensorFlowNET.UnitTest/NameScopeTest.cs b/test/TensorFlowNET.UnitTest/NameScopeTest.cs

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public static ITensorOrOperation[] import_graph_def(GraphDef graph_def,`
`26`	`26`
`27`	`27`	`string prefix = "";`
`28`	`28`	`var graph = ops.get_default_graph();`
`29`		`- with(new ops.name_scope(name, "import", input_map.Values), scope =>`
	`29`	`+ with(ops.name_scope(name, "import", input_map.Values), scope =>`
`30`	`30`	`{`
`31`	`31`	`prefix = scope;`
`32`	`32`	`/*if (!string.IsNullOrEmpty(prefix))`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@ public static object get_collection(string key, string scope = "") => get_defaul`
`16`	`16`	`/// <param name="default_name">The default name to use if the name argument is None.</param>`
`17`	`17`	`/// <param name="values">The list of Tensor arguments that are passed to the op function.</param>`
`18`	`18`	`/// <returns>The scope name.</returns>`
`19`		`- public static ops.name_scope name_scope(string name,`
	`19`	`+ public static ops.NameScope name_scope(string name,`
`20`	`20`	`string default_name = "",`
`21`		`- object values = null) => new ops.name_scope(name, default_name, values);`
	`21`	`+ object values = null) => new ops.NameScope(name, default_name, values);`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public Tensor __call__(Tensor inputs,`
`31`	`31`	`bool build_graph = tf_utils.are_all_symbolic_tensors(input_list);`
`32`	`32`
`33`	`33`	`// Handle Keras mask propagation from previous layer to current layer.`
`34`		`- Python.with(new ops.name_scope(_name_scope()), delegate`
	`34`	`+ Python.with(ops.name_scope(_name_scope()), delegate`
`35`	`35`	`{`
`36`	`36`	`if (!built)`
`37`	`37`	`{`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ protected virtual void add_weight()`
`92`	`92`	`auxiliary_name_scope: false), scope =>`
`93`	`93`	`{`
`94`	`94`	`_current_scope = scope;`
`95`		`- Python.with(new ops.name_scope(_name_scope()), delegate`
	`95`	`+ Python.with(ops.name_scope(_name_scope()), delegate`
`96`	`96`	`{`
`97`	`97`
`98`	`98`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public Normal (Tensor loc, Tensor scale, bool validate_args=false, bool allow_na`
`33`	`33`	`parameters.Add("validate_args", validate_args);`
`34`	`34`	`parameters.Add("allow_nan_stats", allow_nan_stats);`
`35`	`35`
`36`		`- with(new ops.name_scope(name, "", new { loc, scale }), scope =>`
	`36`	`+ with(ops.name_scope(name, "", new { loc, scale }), scope =>`
`37`	`37`	`{`
`38`	`38`	`with(ops.control_dependencies(validate_args ? new Operation[] { scale.op} : new Operation[] { }), cd =>`
`39`	`39`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public Tensor sparse_softmax_cross_entropy(Tensor labels,`
`12`	`12`	`string scope = "",`
`13`	`13`	`string loss_collection= "losses")`
`14`	`14`	`{`
`15`		`- with(new ops.name_scope(scope,`
	`15`	`+ with(ops.name_scope(scope,`
`16`	`16`	`"sparse_softmax_cross_entropy_loss",`
`17`	`17`	`(logits, labels, weights)),`
`18`	`18`	`namescope =>`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ public Operation _apply_op_helper(string op_type_name, string name = null, dynam`
`44`	`44`	`var input_types = new List<TF_DataType>();`
`45`	`45`	`dynamic values = null;`
`46`	`46`
`47`		`- return with(new ops.name_scope(name), scope =>`
	`47`	`+ return with(ops.name_scope(name), scope =>`
`48`	`48`	`{`
`49`	`49`	`var inferred_from = new Dictionary<string, object>();`
`50`	`50`	`var base_types = new List<TF_DataType>();`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public class array_ops : Python`
`12`	`12`	`public static Tensor zeros(Shape shape, TF_DataType dtype = TF_DataType.TF_FLOAT, string name = null)`
`13`	`13`	`{`
`14`	`14`	`dtype = dtype.as_base_dtype();`
`15`		`- return with(new ops.name_scope(name, "zeros", shape), scope =>`
	`15`	`+ return with(ops.name_scope(name, "zeros", shape), scope =>`
`16`	`16`	`{`
`17`	`17`	`name = scope;`
`18`	`18`	`switch (dtype)`
`@@ -68,7 +68,7 @@ public static Tensor ones_like<T>(T tensor, TF_DataType dtype = TF_DataType.DtIn`
`68`	`68`
`69`	`69`	`private static Tensor ones_like_impl<T>(T tensor, TF_DataType dtype, string name, bool optimize = true)`
`70`	`70`	`{`
`71`		`- return with(new ops.name_scope(name, "ones_like", new { tensor }), scope =>`
	`71`	`+ return with(ops.name_scope(name, "ones_like", new { tensor }), scope =>`
`72`	`72`	`{`
`73`	`73`	`name = scope;`
`74`	`74`	`var tensor1 = ops.convert_to_tensor(tensor, name: "tensor");`
`@@ -84,7 +84,7 @@ private static Tensor ones_like_impl<T>(T tensor, TF_DataType dtype, string name`
`84`	`84`	`public static Tensor ones(Tensor shape, TF_DataType dtype = TF_DataType.TF_FLOAT, string name = null)`
`85`	`85`	`{`
`86`	`86`	`dtype = dtype.as_base_dtype();`
`87`		`- return with(new ops.name_scope(name, "ones", new { shape }), scope =>`
	`87`	`+ return with(ops.name_scope(name, "ones", new { shape }), scope =>`
`88`	`88`	`{`
`89`	`89`	`name = scope;`
`90`	`90`	`var output = gen_array_ops.fill(shape, constant_op.constant(1.0f, dtype: dtype), name: name);`
`@@ -130,7 +130,7 @@ public static Tensor size(Tensor input, string name = null, bool optimize = true`
`130`	`130`
`131`	`131`	`private static Tensor shape_internal(Tensor input, string name = null, bool optimize = true, TF_DataType out_type = TF_DataType.TF_INT32)`
`132`	`132`	`{`
`133`		`- return with(new ops.name_scope(name, "Shape", new { input }), scope =>`
	`133`	`+ return with(ops.name_scope(name, "Shape", new { input }), scope =>`
`134`	`134`	`{`
`135`	`135`	`name = scope;`
`136`	`136`
`@@ -151,7 +151,7 @@ private static Tensor shape_internal(Tensor input, string name = null, bool opti`
`151`	`151`
`152`	`152`	`private static Tensor size_internal(Tensor input, string name = null, bool optimize = true, TF_DataType out_type = TF_DataType.TF_INT32)`
`153`	`153`	`{`
`154`		`- return with(new ops.name_scope(name, "Size", new Tensor[] { input }), scope =>`
	`154`	`+ return with(ops.name_scope(name, "Size", new Tensor[] { input }), scope =>`
`155`	`155`	`{`
`156`	`156`	`name = scope;`
`157`	`157`
`@@ -182,7 +182,7 @@ private static Tensor size_internal(Tensor input, string name = null, bool optim`
`182`	`182`
`183`	`183`	`public static Tensor zeros_like(Tensor tensor, TF_DataType dtype = TF_DataType.DtInvalid, string name = null, bool optimize = true)`
`184`	`184`	`{`
`185`		`- return with(new ops.name_scope(name, "zeros_like", new Tensor[] { tensor }), scope =>`
	`185`	`+ return with(ops.name_scope(name, "zeros_like", new Tensor[] { tensor }), scope =>`
`186`	`186`	`{`
`187`	`187`	`name = scope;`
`188`	`188`	`tensor = ops.convert_to_tensor(tensor, name: "tensor");`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ public class control_flow_ops : Python`
`9`	`9`	`{`
`10`	`10`	`public static Operation group<T>(T[] inputs, string name = null) where T : ITensorOrOperation`
`11`	`11`	`{`
`12`		`- return with(new ops.name_scope(name, "group_deps", inputs), scope =>`
	`12`	`+ return with(ops.name_scope(name, "group_deps", inputs), scope =>`
`13`	`13`	`{`
`14`	`14`	`name = scope;`
`15`	`15`
`@@ -83,7 +83,7 @@ private static bool IsLoopExit(Operation op)`
`83`	`83`
`84`	`84`	`public static Tensor[] tuple(Tensor[] tensors, string name = null, Operation[] control_inputs = null)`
`85`	`85`	`{`
`86`		`- return with(new ops.name_scope(name, "tuple", tensors), scope =>`
	`86`	`+ return with(ops.name_scope(name, "tuple", tensors), scope =>`
`87`	`87`	`{`
`88`	`88`	`name = scope;`
`89`	`89`	`var gating_ops = tensors.Select(x => x.op).ToList();`
`@@ -115,7 +115,7 @@ public static Tensor with_dependencies(Operation[] dependencies, Tensor output_t`
`115`	`115`	`values.AddRange(dependencies);`
`116`	`116`	`values.Add(output_tensor);`
`117`	`117`
`118`		`- return with(new ops.name_scope(name, "control_dependency", values), scope =>`
	`118`	`+ return with(ops.name_scope(name, "control_dependency", values), scope =>`
`119`	`119`	`{`
`120`	`120`	`name = scope;`
`121`	`121`