Rollback Fix collections typing #448

Oceania2018 · Oceania2018 · commit 945ac0241553 · 2019-11-14T22:20:50.000-06:00
diff --git a/src/TensorFlowNET.Core/APIs/tf.variable.cs b/src/TensorFlowNET.Core/APIs/tf.variable.cs
@@ -23,14 +23,14 @@ public partial class tensorflow
     {
         public VariableV1[] global_variables(string scope = null)
         {
-            return (ops.get_collection<VariableV1>(tf.GraphKeys.GLOBAL_VARIABLES, scope))
+            return (ops.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope) as List<VariableV1>)
                 .ToArray();
         }
 
         public Operation global_variables_initializer()
         {
             var g = variables.global_variables();
-            return variables.variables_initializer(g?.ToArray());
+            return variables.variables_initializer(g.ToArray());
         }
 
         /// <summary>
@@ -54,9 +54,9 @@ public RefVariable get_variable(string name,
         {
             var scope = Tensorflow.variable_scope.get_variable_scope();
             var store = Tensorflow.variable_scope._get_default_variable_store();
-            return scope.get_variable(store, 
-                name, 
-                shape: shape, 
+            return scope.get_variable(store,
+                name,
+                shape: shape,
                 dtype: dtype,
                 use_resource: use_resource,
                 validate_shape: validate_shape,
diff --git a/src/TensorFlowNET.Core/Binding.FuncTools.cs b/src/TensorFlowNET.Core/Binding.FuncTools.cs
@@ -10,11 +10,23 @@ public static partial class Binding
     {
         public static class functools
         {
-            public static Func<Tin, Tout> partial<Tin, Tout>(Func<Tin, Tout> func, Tin arg)
-                => (arg0) => func(arg0);
+            public static PartialFunc<Tin, Tout> partial<Tin, Tout>(Func<Tin, Tout> func, Tin arg)
+                => new PartialFunc<Tin, Tout>
+                {
+                    args = arg,
+                    invoke = func
+                };
 
             public static Func<Tin1, Tin2, Tout> partial<Tin1, Tin2, Tout>(Func<Tin1, Tin2, Tout> func, (Tin1, Tin2) args)
-                => (arg1, arg2) => func(arg1, arg2);
+                => (arg1, arg2) => func(args.Item1, args.Item2);
+        }
+
+        public class PartialFunc<Tin, Tout>
+        {
+            public Tin args { get; set; }
+            public object[] keywords { get; set; }
+
+            public Func<Tin, Tout> invoke { get; set; }
         }
     }
 }
diff --git a/src/TensorFlowNET.Core/Framework/meta_graph.cs b/src/TensorFlowNET.Core/Framework/meta_graph.cs
@@ -46,9 +46,9 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop
 
             if (!string.IsNullOrEmpty(unbound_inputs_col_name))
             {
-                foreach(var col in meta_graph_def.CollectionDef)
+                foreach (var col in meta_graph_def.CollectionDef)
                 {
-                    if(col.Key == unbound_inputs_col_name)
+                    if (col.Key == unbound_inputs_col_name)
                     {
                         throw new NotImplementedException("import_scoped_meta_graph_with_return_elements");
                     }
@@ -78,7 +78,7 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop
 
             // Restores all the other collections.
             var variable_objects = new Dictionary<ByteString, VariableV1>();
-            foreach(var col in meta_graph_def.CollectionDef.OrderBy(x => x.Key))
+            foreach (var col in meta_graph_def.CollectionDef.OrderBy(x => x.Key))
             {
                 // Don't add unbound_inputs to the new graph.
                 if (col.Key == unbound_inputs_col_name)
@@ -87,7 +87,7 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop
                 switch (col.Value.KindCase)
                 {
                     case KindOneofCase.NodeList:
-                        foreach(var value in col.Value.NodeList.Value)
+                        foreach (var value in col.Value.NodeList.Value)
                         {
                             var col_op = graph.as_graph_element(ops.prepend_name_scope(value, scope_to_prepend_to_names));
                             graph.add_to_collection(col.Key, col_op);
@@ -115,7 +115,7 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop
                         }
                         else
                         {
-                            foreach(var value in col.Value.BytesList.Value)
+                            foreach (var value in col.Value.BytesList.Value)
                             {
                                 switch (col.Key)
                                 {
@@ -139,7 +139,7 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop
                                 }
                             }
                         }
-                        
+
                         break;
                     default:
                         throw new NotImplementedException("import_scoped_meta_graph_with_return_elements");
@@ -173,8 +173,8 @@ public static (MetaGraphDef, Dictionary<string, VariableV1>) export_scoped_meta_
             string unbound_inputs_col_name = "unbound_inputs",
             bool clear_devices = false,
             SaverDef saver_def = null,
-            bool clear_extraneous_savers= false,
-            bool strip_default_attrs= false,
+            bool clear_extraneous_savers = false,
+            bool strip_default_attrs = false,
             byte[] meta_info_def = null)
         {
             var graph = ops.get_default_graph();
@@ -236,12 +236,12 @@ private static MetaGraphDef create_meta_graph_def(MetaInfoDef meta_info_def = nu
                 meta_graph_def.GraphDef = graph_def;
 
             // Fills in meta_info_def.stripped_op_list using the ops from graph_def.
-            if (meta_graph_def.MetaInfoDef.StrippedOpList == null || 
+            if (meta_graph_def.MetaInfoDef.StrippedOpList == null ||
                 meta_graph_def.MetaInfoDef.StrippedOpList.Op.Count == 0)
                 meta_graph_def.MetaInfoDef.StrippedOpList = stripped_op_list_for_graph(meta_graph_def.GraphDef);
 
             var clist = graph.get_all_collection_keys();
-            foreach(var ctype in clist)
+            foreach (var ctype in clist)
             {
                 if (clear_extraneous_savers)
                 {
@@ -256,30 +256,34 @@ private static MetaGraphDef create_meta_graph_def(MetaInfoDef meta_info_def = nu
             return meta_graph_def;
         }
 
-        private static void add_collection_def(MetaGraphDef meta_graph_def, 
-            string key, 
+        private static void add_collection_def(MetaGraphDef meta_graph_def,
+            string key,
             Graph graph = null,
             string export_scope = "")
         {
             if (!meta_graph_def.CollectionDef.ContainsKey(key))
                 meta_graph_def.CollectionDef[key] = new CollectionDef();
             var col_def = meta_graph_def.CollectionDef[key];
-            col_def.NodeList = new Types.NodeList();
-            col_def.BytesList = new Types.BytesList();
-            foreach (object value in graph.get_collection(key))
+
+            switch (graph.get_collection(key))
             {
-                switch (value)
-                {
-                    case RefVariable x:
+                case List<RefVariable> collection_list:
+                    col_def.BytesList = new Types.BytesList();
+                    foreach (var x in collection_list)
+                    {
                         var proto = x.to_proto(export_scope);
                         col_def.BytesList.Value.Add(proto.ToByteString());
-                        break;
-                    case ITensorOrOperation x2:
-                        col_def.NodeList.Value.Add(ops.strip_name_scope(x2.name, export_scope));
-                        break;
-                    default:
-                        break;
-                }
+                    }
+
+                    break;
+                case List<object> collection_list:
+                    col_def.NodeList = new Types.NodeList();
+                    foreach (var x in collection_list)
+                        if (x is ITensorOrOperation x2)
+                            col_def.NodeList.Value.Add(ops.strip_name_scope(x2.name, export_scope));
+                    break;
+                case List<Operation> collection_list:
+                    break;
             }
         }
 
diff --git a/src/TensorFlowNET.Core/Graphs/Graph.cs b/src/TensorFlowNET.Core/Graphs/Graph.cs
@@ -77,7 +77,7 @@ all variables that are created during the construction of a graph. The caller
     /// <remarks>https://www.tensorflow.org/guide/graphs <br></br>https://www.tensorflow.org/api_docs/python/tf/Graph</remarks>
     public partial class Graph : DisposableObject
 #if !SERIALIZABLE
-        ,IEnumerable<Operation>
+        , IEnumerable<Operation>
 #endif
     {
         private Dictionary<int, ITensorOrOperation> _nodes_by_id;
@@ -100,15 +100,13 @@ public partial class Graph : DisposableObject
         /// </summary>
         private bool _finalized = false;
 
-
         /// <summary>
-        /// Arbitrary collections of objects inside the graph.
-        /// TODO: Access might be slow (-> O(n)) depending on size.
+        /// Arbitrary collections of objects.
         /// </summary>
-        private readonly ICollection<(string name, string scope, object item)> _collections = new List<(string name, string scope, object item)>();
+        private Dictionary<string, object> _collections = new Dictionary<string, object>();
 
-        public bool building_function;
-        
+        public bool building_function;
+
         public Graph()
         {
             _handle = c_api.TF_NewGraph();
@@ -230,14 +228,16 @@ private ITensorOrOperation _as_graph_element_locked(object obj, bool allow_tenso
             throw new Exception($"Can not convert a {obj.GetType().Name} into a {types_str}.");
         }
 
-        public void add_to_collection(string name, object value)
+        public void add_to_collection<T>(string name, T value)
         {
             _check_not_finalized();
-            _collections.Add((name, null, value));
+            if (_collections.ContainsKey(name))
+                (_collections[name] as List<T>).Add(value);
+            else
+                _collections[name] = new List<T> { value };
         }
 
-
-        public void add_to_collections(List<string> names, object value)
+        public void add_to_collections<T>(List<string> names, T value)
         {
             foreach (string name in names)
                 add_to_collection(name, value);
@@ -278,6 +278,12 @@ public Operation create_op(string op_type, Tensor[] inputs, TF_DataType[] dtypes
 
             _create_op_helper(op, true);
 
+            /*Console.Write($"create_op: {op_type} '{node_def.Name}'");
+            Console.Write($", inputs: {(inputs.Length == 0 ? "empty" : String.Join(", ", inputs.Select(x => x.name)))}");
+            Console.Write($", control_inputs: {(control_inputs.Length == 0 ? "empty" : String.Join(", ", control_inputs.Select(x => x.name)))}");
+            Console.Write($", outputs: {(op.outputs.Length == 0 ? "empty" : String.Join(", ", op.outputs.Select(x => x.name)))}");
+            Console.WriteLine();*/
+
             return op;
         }
 
@@ -394,7 +400,7 @@ public string unique_name(string name, bool mark_as_used = true)
                     _names_in_use[name_key] = 1;
 
                 // Return the new name with the original capitalization of the given name.
-                name = $"{name}_{i-1}";
+                name = $"{name}_{i - 1}";
             }
             return name;
         }
@@ -407,43 +413,55 @@ public TF_Output[] ReturnOutputs(IntPtr results)
             TF_Output[] return_outputs = new TF_Output[num_return_outputs];
             unsafe
             {
-                var tf_output_ptr = (TF_Output*) return_output_handle;
-                for (int i = 0; i < num_return_outputs; i++) 
+                var tf_output_ptr = (TF_Output*)return_output_handle;
+                for (int i = 0; i < num_return_outputs; i++)
                     return_outputs[i] = *(tf_output_ptr + i);
                 return return_outputs;
             }
         }
 
         public string[] get_all_collection_keys()
         {
-            return (from c in _collections where !c.name.StartsWith("__") select c.name).ToArray();
+            return _collections.Keys.Where(x => !x.StartsWith("__")).ToArray();
         }
 
-        public List<object> get_collection(string name, string scope = null)
+        public object get_collection(string name, string scope = null)
         {
-            return get_collection<object>(name, scope);
-        }
-
-
+            return _collections.ContainsKey(name) ? _collections[name] : null;
+        }
+
         public List<T> get_collection<T>(string name, string scope = null)
-        {
-
-            return (from c in _collections
-                    where c.name == name && 
-                        (scope == null || c.scope == scope) &&
-                        implementationOf<T>(c.item)
-                    select (T)(c.item)).ToList();
-
-        }
-
-        private static bool implementationOf<T>(object item)
-        {
-            return (item.GetType() == typeof(T) || item.GetType().IsSubclassOf(typeof(T)));
-        }
-
+        {
+            List<T> t = default;
+            var collection = _collections.ContainsKey(name) ? _collections[name] : new List<T>();
+            switch (collection)
+            {
+                case List<VariableV1> list:
+                    t = list.Select(x => (T)(object)x).ToList();
+                    break;
+                case List<ResourceVariable> list:
+                    t = list.Select(x => (T)(object)x).ToList();
+                    break;
+                case List<RefVariable> list:
+                    t = list.Select(x => (T)(object)x).ToList();
+                    break;
+                case List<Tensor> list:
+                    t = list.Select(x => (T)(object)x).ToList();
+                    break;
+                case List<Operation> list:
+                    t = list.Select(x => (T)(object)x).ToList();
+                    break;
+                default:
+                    throw new NotImplementedException($"get_collection<{typeof(T).FullName}>");
+            }
+            return t;
+        }
+
         public List<T> get_collection_ref<T>(string name)
         {
-            return get_collection<T>(name);
+            if (!_collections.ContainsKey(name))
+                _collections[name] = new List<T>();
+            return _collections[name] as List<T>;
         }
 
         public void prevent_feeding(Tensor tensor)
@@ -497,7 +515,7 @@ public TensorShape GetTensorShape(TF_Output output)
         string debugString = string.Empty;
         public override string ToString()
         {
-            return $"{graph_key}, ({_handle})"; 
+            return $"{graph_key}, ({_handle})";
             /*if (string.IsNullOrEmpty(debugString))
             {
                 int len = 0;
@@ -514,7 +532,7 @@ private IEnumerable<Operation> GetEnumerable()
         IEnumerator<Operation> IEnumerable<Operation>.GetEnumerator()
             => GetEnumerable().GetEnumerator();
 
-        IEnumerator IEnumerable.GetEnumerator() 
+        IEnumerator IEnumerable.GetEnumerator()
             => throw new NotImplementedException();
 #endif
 
diff --git a/src/TensorFlowNET.Core/Training/TrainingUtil.cs b/src/TensorFlowNET.Core/Training/TrainingUtil.cs
@@ -16,7 +16,7 @@ public static RefVariable create_global_step(Graph graph = null)
             // Create in proper graph and base name_scope.
             var g = graph.as_default();
             g.name_scope(null);
-            var v = tf.get_variable(tf.GraphKeys.GLOBAL_STEP, new TensorShape(), dtype: dtypes.int64,
+            var v = tf.get_variable(tf.GraphKeys.GLOBAL_STEP, new int[0], dtype: dtypes.int64,
                 initializer: tf.zeros_initializer,
                 trainable: false,
                 aggregation: VariableAggregation.OnlyFirstReplica,
diff --git a/src/TensorFlowNET.Core/Variables/variable_scope.py.cs b/src/TensorFlowNET.Core/Variables/variable_scope.py.cs
diff --git a/src/TensorFlowNET.Core/ops.cs b/src/TensorFlowNET.Core/ops.cs

Original file line number	Diff line number	Diff line change
`@@ -23,14 +23,14 @@ public partial class tensorflow`
`23`	`23`	`{`
`24`	`24`	`public VariableV1[] global_variables(string scope = null)`
`25`	`25`	`{`
`26`		`- return (ops.get_collection<VariableV1>(tf.GraphKeys.GLOBAL_VARIABLES, scope))`
	`26`	`+ return (ops.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope) as List<VariableV1>)`
`27`	`27`	`.ToArray();`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`public Operation global_variables_initializer()`
`31`	`31`	`{`
`32`	`32`	`var g = variables.global_variables();`
`33`		`- return variables.variables_initializer(g?.ToArray());`
	`33`	`+ return variables.variables_initializer(g.ToArray());`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`/// <summary>`
`@@ -54,9 +54,9 @@ public RefVariable get_variable(string name,`
`54`	`54`	`{`
`55`	`55`	`var scope = Tensorflow.variable_scope.get_variable_scope();`
`56`	`56`	`var store = Tensorflow.variable_scope._get_default_variable_store();`
`57`		`- return scope.get_variable(store,`
`58`		`- name,`
`59`		`- shape: shape,`
	`57`	`+ return scope.get_variable(store,`
	`58`	`+ name,`
	`59`	`+ shape: shape,`
`60`	`60`	`dtype: dtype,`
`61`	`61`	`use_resource: use_resource,`
`62`	`62`	`validate_shape: validate_shape,`
Original file line number	Diff line number	Diff line change
`@@ -10,11 +10,23 @@ public static partial class Binding`
`10`	`10`	`{`
`11`	`11`	`public static class functools`
`12`	`12`	`{`
`13`		`- public static Func<Tin, Tout> partial<Tin, Tout>(Func<Tin, Tout> func, Tin arg)`
`14`		`- => (arg0) => func(arg0);`
	`13`	`+ public static PartialFunc<Tin, Tout> partial<Tin, Tout>(Func<Tin, Tout> func, Tin arg)`
	`14`	`+ => new PartialFunc<Tin, Tout>`
	`15`	`+ {`
	`16`	`+ args = arg,`
	`17`	`+ invoke = func`
	`18`	`+ };`
`15`	`19`
`16`	`20`	`public static Func<Tin1, Tin2, Tout> partial<Tin1, Tin2, Tout>(Func<Tin1, Tin2, Tout> func, (Tin1, Tin2) args)`
`17`		`- => (arg1, arg2) => func(arg1, arg2);`
	`21`	`+ => (arg1, arg2) => func(args.Item1, args.Item2);`
	`22`	`+ }`
	`23`	`+`
	`24`	`+ public class PartialFunc<Tin, Tout>`
	`25`	`+ {`
	`26`	`+ public Tin args { get; set; }`
	`27`	`+ public object[] keywords { get; set; }`
	`28`	`+`
	`29`	`+ public Func<Tin, Tout> invoke { get; set; }`
`18`	`30`	`}`
`19`	`31`	`}`
`20`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,9 +46,9 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop`
`46`	`46`
`47`	`47`	`if (!string.IsNullOrEmpty(unbound_inputs_col_name))`
`48`	`48`	`{`
`49`		`- foreach(var col in meta_graph_def.CollectionDef)`
	`49`	`+ foreach (var col in meta_graph_def.CollectionDef)`
`50`	`50`	`{`
`51`		`- if(col.Key == unbound_inputs_col_name)`
	`51`	`+ if (col.Key == unbound_inputs_col_name)`
`52`	`52`	`{`
`53`	`53`	`throw new NotImplementedException("import_scoped_meta_graph_with_return_elements");`
`54`	`54`	`}`
`@@ -78,7 +78,7 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop`
`78`	`78`
`79`	`79`	`// Restores all the other collections.`
`80`	`80`	`var variable_objects = new Dictionary<ByteString, VariableV1>();`
`81`		`- foreach(var col in meta_graph_def.CollectionDef.OrderBy(x => x.Key))`
	`81`	`+ foreach (var col in meta_graph_def.CollectionDef.OrderBy(x => x.Key))`
`82`	`82`	`{`
`83`	`83`	`// Don't add unbound_inputs to the new graph.`
`84`	`84`	`if (col.Key == unbound_inputs_col_name)`
`@@ -87,7 +87,7 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop`
`87`	`87`	`switch (col.Value.KindCase)`
`88`	`88`	`{`
`89`	`89`	`case KindOneofCase.NodeList:`
`90`		`- foreach(var value in col.Value.NodeList.Value)`
	`90`	`+ foreach (var value in col.Value.NodeList.Value)`
`91`	`91`	`{`
`92`	`92`	`var col_op = graph.as_graph_element(ops.prepend_name_scope(value, scope_to_prepend_to_names));`
`93`	`93`	`graph.add_to_collection(col.Key, col_op);`
`@@ -115,7 +115,7 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop`
`115`	`115`	`}`
`116`	`116`	`else`
`117`	`117`	`{`
`118`		`- foreach(var value in col.Value.BytesList.Value)`
	`118`	`+ foreach (var value in col.Value.BytesList.Value)`
`119`	`119`	`{`
`120`	`120`	`switch (col.Key)`
`121`	`121`	`{`
`@@ -139,7 +139,7 @@ public static (Dictionary<string, VariableV1>, ITensorOrOperation[]) import_scop`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`	`}`
`142`		`-`
	`142`	`+`
`143`	`143`	`break;`
`144`	`144`	`default:`
`145`	`145`	`throw new NotImplementedException("import_scoped_meta_graph_with_return_elements");`
`@@ -173,8 +173,8 @@ public static (MetaGraphDef, Dictionary<string, VariableV1>) export_scoped_meta_`
`173`	`173`	`string unbound_inputs_col_name = "unbound_inputs",`
`174`	`174`	`bool clear_devices = false,`
`175`	`175`	`SaverDef saver_def = null,`
`176`		`- bool clear_extraneous_savers= false,`
`177`		`- bool strip_default_attrs= false,`
	`176`	`+ bool clear_extraneous_savers = false,`
	`177`	`+ bool strip_default_attrs = false,`
`178`	`178`	`byte[] meta_info_def = null)`
`179`	`179`	`{`
`180`	`180`	`var graph = ops.get_default_graph();`
`@@ -236,12 +236,12 @@ private static MetaGraphDef create_meta_graph_def(MetaInfoDef meta_info_def = nu`
`236`	`236`	`meta_graph_def.GraphDef = graph_def;`
`237`	`237`
`238`	`238`	`// Fills in meta_info_def.stripped_op_list using the ops from graph_def.`
`239`		`- if (meta_graph_def.MetaInfoDef.StrippedOpList == null \|\|`
	`239`	`+ if (meta_graph_def.MetaInfoDef.StrippedOpList == null \|\|`
`240`	`240`	`meta_graph_def.MetaInfoDef.StrippedOpList.Op.Count == 0)`
`241`	`241`	`meta_graph_def.MetaInfoDef.StrippedOpList = stripped_op_list_for_graph(meta_graph_def.GraphDef);`
`242`	`242`
`243`	`243`	`var clist = graph.get_all_collection_keys();`
`244`		`- foreach(var ctype in clist)`
	`244`	`+ foreach (var ctype in clist)`
`245`	`245`	`{`
`246`	`246`	`if (clear_extraneous_savers)`
`247`	`247`	`{`
`@@ -256,30 +256,34 @@ private static MetaGraphDef create_meta_graph_def(MetaInfoDef meta_info_def = nu`
`256`	`256`	`return meta_graph_def;`
`257`	`257`	`}`
`258`	`258`
`259`		`- private static void add_collection_def(MetaGraphDef meta_graph_def,`
`260`		`- string key,`
	`259`	`+ private static void add_collection_def(MetaGraphDef meta_graph_def,`
	`260`	`+ string key,`
`261`	`261`	`Graph graph = null,`
`262`	`262`	`string export_scope = "")`
`263`	`263`	`{`
`264`	`264`	`if (!meta_graph_def.CollectionDef.ContainsKey(key))`
`265`	`265`	`meta_graph_def.CollectionDef[key] = new CollectionDef();`
`266`	`266`	`var col_def = meta_graph_def.CollectionDef[key];`
`267`		`- col_def.NodeList = new Types.NodeList();`
`268`		`- col_def.BytesList = new Types.BytesList();`
`269`		`- foreach (object value in graph.get_collection(key))`
	`267`	`+`
	`268`	`+ switch (graph.get_collection(key))`
`270`	`269`	`{`
`271`		`- switch (value)`
`272`		`- {`
`273`		`- case RefVariable x:`
	`270`	`+ case List<RefVariable> collection_list:`
	`271`	`+ col_def.BytesList = new Types.BytesList();`
	`272`	`+ foreach (var x in collection_list)`
	`273`	`+ {`
`274`	`274`	`var proto = x.to_proto(export_scope);`
`275`	`275`	`col_def.BytesList.Value.Add(proto.ToByteString());`
`276`		`- break;`
`277`		`- case ITensorOrOperation x2:`
`278`		`- col_def.NodeList.Value.Add(ops.strip_name_scope(x2.name, export_scope));`
`279`		`- break;`
`280`		`- default:`
`281`		`- break;`
`282`		`- }`
	`276`	`+ }`
	`277`	`+`
	`278`	`+ break;`
	`279`	`+ case List<object> collection_list:`
	`280`	`+ col_def.NodeList = new Types.NodeList();`
	`281`	`+ foreach (var x in collection_list)`
	`282`	`+ if (x is ITensorOrOperation x2)`
	`283`	`+ col_def.NodeList.Value.Add(ops.strip_name_scope(x2.name, export_scope));`
	`284`	`+ break;`
	`285`	`+ case List<Operation> collection_list:`
	`286`	`+ break;`
`283`	`287`	`}`
`284`	`288`	`}`
`285`	`289`