fix internal_convert_n_to_tensor return type.

Oceania2018 · Oceania2018 · commit 1c5731faf5cc · 2019-02-05T16:54:50.000-06:00
diff --git a/src/TensorFlowNET.Core/Operations/OpDefLibrary.cs b/src/TensorFlowNET.Core/Operations/OpDefLibrary.cs
@@ -84,32 +84,25 @@ public Operation _apply_op_helper(string op_type_name, string name = "", dynamic
                             dtype = dtype.as_base_dtype();
 
                         values = ops.internal_convert_n_to_tensor(values, name: input_arg.Name, dtype: dtype, preferred_dtype: default_dtype, as_ref: input_arg.IsRef);
-                        
-                        inputs.AddRange(values as Tensor[]);
                     }
                     else
                     {
-                        if (!(values is Tensor))
+                        if (keywords[input_name] is Tensor)
                         {
-                            keywords[input_name] = constant_op.constant(values, input_name);
                         }
-
-                        if (keywords[input_name] is Tensor value)
+                        else
                         {
-                            if (keywords.ContainsKey(input_name))
-                            {
-                                inputs.Add(value);
-                            }
-
-                            if (!String.IsNullOrEmpty(input_arg.TypeAttr))
-                            {
-                                attrs[input_arg.TypeAttr] = value.dtype;
-                            }
+                            keywords[input_name] = ops.internal_convert_to_tensor(values, name: input_name);
+                        }
 
-                            values = new Tensor[] { value };
+                        if (!String.IsNullOrEmpty(input_arg.TypeAttr))
+                        {
+                            attrs[input_arg.TypeAttr] = (keywords[input_name] as Tensor).dtype;
                         }
+                        values = new Tensor[] { keywords[input_name] as Tensor };
                     }
 
+                    inputs.AddRange(values as Tensor[]);
                     base_types.AddRange((values as Tensor[]).Select(x => x.dtype.as_base_dtype()));
                     input_types.AddRange(base_types);
                 }
diff --git a/src/TensorFlowNET.Core/ops.py.cs b/src/TensorFlowNET.Core/ops.py.cs
@@ -310,11 +310,11 @@ public static Session get_default_session()
             };
         }
 
-        public static T[] internal_convert_n_to_tensor<T>(T[] values, DataType dtype = DataType.DtInvalid, 
+        public static Tensor[] internal_convert_n_to_tensor<T>(T[] values, DataType dtype = DataType.DtInvalid, 
             string name = "", DataType preferred_dtype = DataType.DtInvalid, 
             bool as_ref = false)
         {
-            var ret = new List<T>();
+            var ret = new List<Tensor>();
 
             foreach((int i, T value) in Python.enumerate(values))
             {
@@ -325,16 +325,16 @@ public static T[] internal_convert_n_to_tensor<T>(T[] values, DataType dtype = D
             return ret.ToArray();
         }
 
-        public static T internal_convert_to_tensor<T>(T value, DataType dtype = DataType.DtInvalid,
+        public static Tensor internal_convert_to_tensor<T>(T value, DataType dtype = DataType.DtInvalid,
             string name = "", DataType preferred_dtype = DataType.DtInvalid,
             bool as_ref = false)
         {
             switch (typeof(T).Name)
             {
                 case "Tensor":
-                    return value;
+                    return value as Tensor;
                 default:
-                    throw new NotImplementedException("internal_convert_to_tensor");
+                    return constant_op.constant(np.array(value), name);
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -84,32 +84,25 @@ public Operation _apply_op_helper(string op_type_name, string name = "", dynamic`
`84`	`84`	`dtype = dtype.as_base_dtype();`
`85`	`85`
`86`	`86`	`values = ops.internal_convert_n_to_tensor(values, name: input_arg.Name, dtype: dtype, preferred_dtype: default_dtype, as_ref: input_arg.IsRef);`
`87`		`-`
`88`		`- inputs.AddRange(values as Tensor[]);`
`89`	`87`	`}`
`90`	`88`	`else`
`91`	`89`	`{`
`92`		`- if (!(values is Tensor))`
	`90`	`+ if (keywords[input_name] is Tensor)`
`93`	`91`	`{`
`94`		`- keywords[input_name] = constant_op.constant(values, input_name);`
`95`	`92`	`}`
`96`		`-`
`97`		`- if (keywords[input_name] is Tensor value)`
	`93`	`+ else`
`98`	`94`	`{`
`99`		`- if (keywords.ContainsKey(input_name))`
`100`		`- {`
`101`		`- inputs.Add(value);`
`102`		`- }`
`103`		`-`
`104`		`- if (!String.IsNullOrEmpty(input_arg.TypeAttr))`
`105`		`- {`
`106`		`- attrs[input_arg.TypeAttr] = value.dtype;`
`107`		`- }`
	`95`	`+ keywords[input_name] = ops.internal_convert_to_tensor(values, name: input_name);`
	`96`	`+ }`
`108`	`97`
`109`		`- values = new Tensor[] { value };`
	`98`	`+ if (!String.IsNullOrEmpty(input_arg.TypeAttr))`
	`99`	`+ {`
	`100`	`+ attrs[input_arg.TypeAttr] = (keywords[input_name] as Tensor).dtype;`
`110`	`101`	`}`
	`102`	`+ values = new Tensor[] { keywords[input_name] as Tensor };`
`111`	`103`	`}`
`112`	`104`
	`105`	`+ inputs.AddRange(values as Tensor[]);`
`113`	`106`	`base_types.AddRange((values as Tensor[]).Select(x => x.dtype.as_base_dtype()));`
`114`	`107`	`input_types.AddRange(base_types);`
`115`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -310,11 +310,11 @@ public static Session get_default_session()`
`310`	`310`	`};`
`311`	`311`	`}`
`312`	`312`
`313`		`- public static T[] internal_convert_n_to_tensor<T>(T[] values, DataType dtype = DataType.DtInvalid,`
	`313`	`+ public static Tensor[] internal_convert_n_to_tensor<T>(T[] values, DataType dtype = DataType.DtInvalid,`
`314`	`314`	`string name = "", DataType preferred_dtype = DataType.DtInvalid,`
`315`	`315`	`bool as_ref = false)`
`316`	`316`	`{`
`317`		`- var ret = new List<T>();`
	`317`	`+ var ret = new List<Tensor>();`
`318`	`318`
`319`	`319`	`foreach((int i, T value) in Python.enumerate(values))`
`320`	`320`	`{`
`@@ -325,16 +325,16 @@ public static T[] internal_convert_n_to_tensor<T>(T[] values, DataType dtype = D`
`325`	`325`	`return ret.ToArray();`
`326`	`326`	`}`
`327`	`327`
`328`		`- public static T internal_convert_to_tensor<T>(T value, DataType dtype = DataType.DtInvalid,`
	`328`	`+ public static Tensor internal_convert_to_tensor<T>(T value, DataType dtype = DataType.DtInvalid,`
`329`	`329`	`string name = "", DataType preferred_dtype = DataType.DtInvalid,`
`330`	`330`	`bool as_ref = false)`
`331`	`331`	`{`
`332`	`332`	`switch (typeof(T).Name)`
`333`	`333`	`{`
`334`	`334`	`case "Tensor":`
`335`		`- return value;`
	`335`	`+ return value as Tensor;`
`336`	`336`	`default:`
`337`		`- throw new NotImplementedException("internal_convert_to_tensor");`
	`337`	`+ return constant_op.constant(np.array(value), name);`
`338`	`338`	`}`
`339`	`339`	`}`
`340`	`340`	`}`