refactor: gen_nn_ops, gen_math_ops, gen_array_ops and related codes.

Author: SanftMonster

src/TensorFlowNET.Console/MemoryBasicTest.cs

@@ -112,7 +112,7 @@ public Action<int, int> Conv2DWithTensor
                 var strides = new[] { 1, 1, 1, 1 };
                 var dilations = new[] { 1, 1, 1, 1 };
 
-                var results = tf.Runner.TFE_FastPathExecute(new FastPathOpExecInfo("Conv2D", null, input, filter)
+                var results = tf.Runner.TFE_FastPathExecute(new FastPathOpExecInfo(tf.Context, "Conv2D", null, input, filter)
                 {
                     attrs = ConvertToDict(new
                     {
@@ -134,7 +134,7 @@ public Action<int, int> Conv2DWithVariable
                 var strides = new[] { 1, 1, 1, 1 };
                 var dilations = new[] { 1, 1, 1, 1 };
 
-                var results = tf.Runner.TFE_FastPathExecute(new FastPathOpExecInfo("Conv2D", null, input, filter)
+                var results = tf.Runner.TFE_FastPathExecute(new FastPathOpExecInfo(tf.Context, "Conv2D", null, input, filter)
                 {
                     attrs = ConvertToDict(new
                     {

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

@@ -44,7 +44,8 @@ public partial class tensorflow
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor batch_to_space_nd<T>(T input, int[] block_shape, int[,] crops, string name = null)
-            => gen_array_ops.batch_to_space_nd(input, block_shape, crops, name: name);
+            => gen_array_ops.batch_to_space_nd(ops.convert_to_tensor(input), ops.convert_to_tensor(block_shape), 
+                ops.convert_to_tensor(crops), name: name);
 
         /// <summary>
         /// Apply boolean mask to tensor.
@@ -91,7 +92,7 @@ public Tensor concat(IEnumerable<Tensor> values, int axis, string name = "concat
                 });
             }
 
-            return gen_array_ops.concat_v2(values.ToArray(), axis, name: name);
+            return gen_array_ops.concat_v2(values.ToArray(), ops.convert_to_tensor(axis), name: name);
         }
 
         /// <summary>
@@ -115,7 +116,7 @@ public Tensor expand_dims(Tensor input, int axis = -1, string name = null)
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor fill<T>(Tensor dims, T value, string name = null)
-            => gen_array_ops.fill(dims, value, name: name);
+            => gen_array_ops.fill(dims, ops.convert_to_tensor(value), name: name);
 
         public Tensor fill<T>(Shape dims, T value, string name = null)
             => array_ops.fill(dims, value, name: name);
@@ -138,7 +139,7 @@ public Tensor identity(Tensor input, string name = null)
         /// <param name="axis"></param>
         /// <returns></returns>
         public Tensor gather(Tensor @params, Tensor indices, string name = null, int axis = 0)
-            => array_ops.gather(@params, indices, name: name, axis: axis);
+            => array_ops.gather(@params, indices, name: name, axis: ops.convert_to_tensor(axis));
 
         /// <summary>
         /// Return the elements, either from `x` or `y`, depending on the `condition`.
@@ -166,7 +167,7 @@ public Tensor transpose<T1>(T1 a, Axis perm = null, string name = "transpose", b
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor reverse(Tensor tensor, int[] axis, string name = null)
-            => gen_array_ops.reverse(tensor, axis, name: name);
+            => gen_array_ops.reverse(tensor, ops.convert_to_tensor(axis), name: name);
 
         public Tensor reverse(Tensor tensor, Tensor axis, string name = null)
             => gen_array_ops.reverse(tensor, axis, name: name);
@@ -189,7 +190,8 @@ public Tensor rank(Tensor input, string name = null)
         /// <param name="name">A name for the operation (optional).</param>
         /// <returns>A `Tensor` the same type as `input`.</returns>
         public Tensor slice<Tb, Ts>(Tensor input, Tb[] begin, Ts[] size, string name = null)
-            => array_ops.slice(input, begin, size, name: name);
+            => array_ops.slice(input, begin.Select(x => ops.convert_to_tensor(x)).ToArray(), 
+                size.Select(x => ops.convert_to_tensor(x)).ToArray(), name: name);
 
         public Tensor squeeze(Tensor input, int axis, string name = null, int squeeze_dims = -1)
             => array_ops.squeeze(input, new[] { axis }, name);
@@ -255,7 +257,7 @@ public Tensor pad(Tensor tensor, Tensor paddings, string mode = "CONSTANT", stri
         /// <param name="name">A name for the operation (optional).</param>
         /// <returns>A `Tensor`. Has the same type as `input`.</returns>
         public Tensor placeholder_with_default<T>(T input, int[] shape, string name = null)
-            => gen_array_ops.placeholder_with_default(input, shape, name: name);
+            => gen_array_ops.placeholder_with_default(ops.convert_to_tensor(input), shape, name: name);
 
         /// <summary>
         /// Returns the shape of a tensor.

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

@@ -130,7 +130,7 @@ public Tensor add(Tensor a, Tensor b, string name = null)
             => gen_math_ops.add(a, b, name: name);
 
         public Tensor add<Tx, Ty>(Tx a, Ty b, string name = null)
-            => gen_math_ops.add(a, b, name: name);
+            => gen_math_ops.add(ops.convert_to_tensor(a), ops.convert_to_tensor(b), name: name);
 
         /// <summary>
         /// Adds all input tensors element-wise.
@@ -151,10 +151,10 @@ public Tensor atan(Tensor x, string name = null)
             => gen_math_ops.atan(x, name);
 
         public Tensor arg_max(Tensor input, int dimension, TF_DataType output_type = TF_DataType.TF_INT64, string name = null)
-            => gen_math_ops.arg_max(input, dimension, output_type: output_type, name: name);
+            => gen_math_ops.arg_max(input, ops.convert_to_tensor(dimension), output_type: output_type, name: name);
 
         public Tensor arg_min(Tensor input, int dimension, TF_DataType output_type = TF_DataType.TF_INT64, string name = null)
-            => gen_math_ops.arg_min(input, dimension, output_type: output_type, name: name);
+            => gen_math_ops.arg_min(input, ops.convert_to_tensor(dimension), output_type: output_type, name: name);
 
         public Tensor is_finite(Tensor input, string name = null)
             => gen_math_ops.is_finite(input, name);
@@ -199,7 +199,7 @@ public Tensor cos(Tensor x, string name = null)
             => gen_math_ops.cos(x, name);
 
         public Tensor cos(float x, string name = null)
-            => gen_math_ops.cos(x, name);
+            => gen_math_ops.cos(ops.convert_to_tensor(x), name);
 
         /// <summary>
         /// Computes hyperbolic cosine of x element-wise.
@@ -235,7 +235,7 @@ public Tensor floor(Tensor x, string name = null)
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor greater<Tx, Ty>(Tx x, Ty y, string name = null)
-            => gen_math_ops.greater(x, y, name);
+            => gen_math_ops.greater(ops.convert_to_tensor(x), ops.convert_to_tensor(y), name);
 
         /// <summary>
         /// Returns the truth value of (x >= y) element-wise.
@@ -247,7 +247,7 @@ public Tensor greater<Tx, Ty>(Tx x, Ty y, string name = null)
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor greater_equal<Tx, Ty>(Tx x, Ty y, string name = null)
-            => gen_math_ops.greater_equal(x, y, name);
+            => gen_math_ops.greater_equal(ops.convert_to_tensor(x), ops.convert_to_tensor(y), name);
 
         /// <summary>
         /// Returns the truth value of (x &lt; y) element-wise.
@@ -259,7 +259,7 @@ public Tensor greater_equal<Tx, Ty>(Tx x, Ty y, string name = null)
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor less<Tx, Ty>(Tx x, Ty y, string name = null)
-            => gen_math_ops.less(x, y, name);
+            => gen_math_ops.less(ops.convert_to_tensor(x), ops.convert_to_tensor(y), name);
 
         /// <summary>
         /// Computes the log of the absolute value of `Gamma(x)` element-wise.
@@ -280,7 +280,7 @@ public Tensor lgamma(Tensor x, string name = null)
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor less_equal<Tx, Ty>(Tx x, Ty y, string name = null)
-            => gen_math_ops.less_equal(x, y, name);
+            => gen_math_ops.less_equal(ops.convert_to_tensor(x), ops.convert_to_tensor(y), name);
 
         /// <summary>
         /// Computes natural logarithm of (1 + x) element-wise.
@@ -292,7 +292,7 @@ public Tensor log1p(Tensor x, string name = null)
             => gen_math_ops.log1p(x, name);
 
         public Tensor logical_and<T>(T x, T y, string name = null)
-            => gen_math_ops.logical_and(x, y, name);
+            => gen_math_ops.logical_and(ops.convert_to_tensor(x), ops.convert_to_tensor(y), name);
 
         public Tensor logical_not(Tensor x, string name = null)
             => gen_math_ops.logical_not(x, name);
@@ -301,7 +301,10 @@ public Tensor logical_or(Tensor x, Tensor y, string name = null)
             => gen_math_ops.logical_or(x, y, name);
 
         public Tensor logical_xor(Tensor x, Tensor y, string name = "LogicalXor")
-            => gen_math_ops.logical_xor(x, y, name);
+        {
+            return gen_math_ops.logical_and(gen_math_ops.logical_or(x, y), 
+                gen_math_ops.logical_not(gen_math_ops.logical_and(x, y)), name);
+        }
 
         /// <summary>
         /// Clips tensor values to a specified min and max.
@@ -312,7 +315,7 @@ public Tensor logical_xor(Tensor x, Tensor y, string name = "LogicalXor")
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor _clip_by_value(Tensor t, Tensor clip_value_min, Tensor clip_value_max, string name = null)
-            => gen_math_ops._clip_by_value(t, clip_value_min, clip_value_max);
+            => gen_math_ops.clip_by_value(t, clip_value_min, clip_value_max);
 
         /// <summary>
         ///    Clips tensor values to a specified min and max.
@@ -345,7 +348,7 @@ public Tensor clip_by_value<T1, T2>(Tensor t, T1 clip_value_min, T2 clip_value_m
             => clip_ops.clip_by_value(t, clip_value_min, clip_value_max, name);
 
         public Tensor sub<Tx, Ty>(Tx a, Ty b, string name = null)
-            => gen_math_ops.sub(a, b, name: name);
+            => gen_math_ops.sub(ops.convert_to_tensor(a), ops.convert_to_tensor(b), name: name);
 
         public Tensor divide(Tensor a, Tensor b)
             => a / b;
@@ -396,7 +399,7 @@ public Tensor atan2(Tensor y, Tensor x, string name = null)
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor max<Tx, Ty>(Tx input, Ty axis, bool keep_dims = false, string name = null)
-            => gen_math_ops._max(input, axis, keep_dims: keep_dims, name: name);
+            => gen_math_ops.max(ops.convert_to_tensor(input), ops.convert_to_tensor(axis), keep_dims: keep_dims, name: name);
 
         /// <summary>
         /// Computes the minimum of elements across dimensions of a tensor.
@@ -409,7 +412,7 @@ public Tensor max<Tx, Ty>(Tx input, Ty axis, bool keep_dims = false, string name
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor min<Tx, Ty>(Tx input, Ty axis, bool keep_dims = false, string name = null)
-            => gen_math_ops._min(input, axis, keep_dims: keep_dims, name: name);
+            => gen_math_ops.min(ops.convert_to_tensor(input), ops.convert_to_tensor(axis), keep_dims: keep_dims, name: name);
 
         /// <summary>
         /// Returns the max of x and y (i.e. x > y ? x : y) element-wise.
@@ -421,7 +424,7 @@ public Tensor min<Tx, Ty>(Tx input, Ty axis, bool keep_dims = false, string name
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor maximum<T1, T2>(T1 x, T2 y, string name = null)
-            => gen_math_ops.maximum(x, y, name: name);
+            => gen_math_ops.maximum(ops.convert_to_tensor(x), ops.convert_to_tensor(y), name: name);
 
         /// <summary>
         /// Returns the min of x and y (i.e. x &lt; y ? x : y) element-wise.
@@ -433,7 +436,7 @@ public Tensor maximum<T1, T2>(T1 x, T2 y, string name = null)
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor minimum<T1, T2>(T1 x, T2 y, string name = null)
-            => gen_math_ops.minimum(x, y, name: name);
+            => gen_math_ops.minimum(ops.convert_to_tensor(x), ops.convert_to_tensor(y), name: name);
 
         public Tensor multiply(Tensor x, Tensor y, string name = null)
             => gen_math_ops.mul(x, y, name: name);
@@ -448,7 +451,7 @@ public Tensor multiply(Tensor x, Tensor y, string name = null)
         /// <param name="name"></param>
         /// <returns></returns>
         public Tensor multiply<Tx, Ty>(Tx x, Ty y, string name = null)
-            => gen_math_ops.mul(x, y, name: name);
+            => gen_math_ops.mul(ops.convert_to_tensor(x), ops.convert_to_tensor(y), name: name);
 
         public Tensor negative(Tensor x, string name = null)
             => gen_math_ops.neg(x, name);
@@ -577,7 +580,7 @@ public Tensor sigmoid<T>(T x, string name = null)
             => math_ops.sigmoid(x, name: name);
 
         public Tensor sum(Tensor input, int axis, bool keep_dims = false, string name = null)
-            => gen_math_ops._sum(input, axis, keep_dims: keep_dims, name: name);
+            => gen_math_ops.sum(input, ops.convert_to_tensor(axis), keep_dims: keep_dims, name: name);
 
         public Tensor reduce_mean(Tensor input_tensor, Axis? axis = null, bool keepdims = false, string name = null, int? reduction_indices = null)
             => math_ops.reduce_mean(input_tensor, axis: axis, keepdims: keepdims, name: name, reduction_indices: reduction_indices);

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

@@ -29,21 +29,8 @@ public class nn_internal
             public Tensor conv2d(Tensor input, Tensor filter, int[] strides, string padding, bool use_cudnn_on_gpu = true,
                 string data_format = "NHWC", int[] dilations = null, string name = null)
             {
-                var parameters = new Conv2dParams
-                {
-                    Input = input,
-                    Filter = filter,
-                    Strides = strides,
-                    Padding = padding,
-                    UseCudnnOnGpu = use_cudnn_on_gpu,
-                    DataFormat = data_format,
-                    Name = name
-                };
-
-                if (dilations != null)
-                    parameters.Dilations = dilations;
-
-                return gen_nn_ops.conv2d(parameters);
+                return gen_nn_ops.conv2d(input, filter, strides, padding, use_cudnn_on_gpu, 
+                    data_format: data_format, dilations: dilations, name: name);
             }
 
             public Tensor[] ctc_greedy_decoder(Tensor inputs, Tensor sequence_length, bool merge_repeated = true, string name = null)
@@ -118,7 +105,7 @@ public Tensor embedding_lookup(Tensor @params,
 
             public IActivation softmax() => new softmax();
             public Tensor tanh(Tensor x, string name = null)
-                => gen_nn_ops.tanh(x, name);
+                => gen_math_ops.tanh(x, name);
 
             public Tensor relu(Tensor features, string name = null)
                 => gen_nn_ops.relu(features, name);
@@ -146,14 +133,14 @@ public Tensor in_top_k(Tensor predictions, Tensor targets, int k, string name =
                 => nn_ops.in_top_k(predictions, targets, k, name);
 
             public Tensor[] top_k(Tensor input, int k = 1, bool sorted = true, string name = null)
-                => gen_nn_ops.top_kv2(input, k: k, sorted: sorted, name: name);
+                => gen_nn_ops.top_kv2(input, k: ops.convert_to_tensor(k), sorted: sorted, name: name);
 
             public Tensor bias_add(Tensor value, IVariableV1 bias, string data_format = null, string name = null)
             {
                 return tf_with(ops.name_scope(name, "BiasAdd", new { value, bias }), scope =>
                 {
                     name = scope;
-                    return gen_nn_ops.bias_add(value, bias, data_format: data_format, name: name);
+                    return gen_nn_ops.bias_add(value, ops.convert_to_tensor(bias), data_format: data_format, name: name);
                 });
             }
 
@@ -172,7 +159,7 @@ public Tensor l2_loss(Tensor t, string name = null)
             /// <returns></returns>
             public Tensor lrn(Tensor input, int depth_radius = 5, int bias = 1,
                 int alpha = 1, float beta = 0.5f, string name = null)
-                => gen_nn_ops.local_response_normalization(input, depth_radius: depth_radius, bias: bias,
+                => gen_nn_ops.lrn(input, depth_radius: depth_radius, bias: bias,
                     alpha: alpha, beta: beta, name: name);
 
             public Tensor leaky_relu(Tensor features, float alpha = 0.2f, string name = null)

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

@@ -31,6 +31,6 @@ public Tensor reshape(Tensor tensor,
         public Tensor reshape(Tensor tensor,
                 object[] shape,
                 string name = null)
-            => gen_array_ops.reshape(tensor, shape, name);
+            => gen_array_ops.reshape(tensor, ops.convert_to_tensor(shape), name);
     }
 }

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

@@ -46,10 +46,10 @@ public Tensor strided_slice<T>(Tensor input, T[] begin, T[] end, T[] strides = n
             int ellipsis_mask = 0,
             int new_axis_mask = 0,
             int shrink_axis_mask = 0,
-            string name = null) => gen_array_ops.strided_slice(input: input,
-                begin: begin,
-                end: end,
-                strides: strides,
+            string name = null) => array_ops.strided_slice(input,
+                begin: ops.convert_to_tensor(begin),
+                end: ops.convert_to_tensor(end),
+                strides: ops.convert_to_tensor(strides),
                 begin_mask: begin_mask,
                 end_mask: end_mask,
                 ellipsis_mask: ellipsis_mask,

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

@@ -23,7 +23,7 @@ public Tensor tile(Tensor input, Tensor multiples, string name = null)
             => gen_array_ops.tile(input, multiples, name);
 
         public Tensor tile(Tensor input, object[] multiples, string name = null)
-            => gen_array_ops.tile(input, multiples, name);
+            => gen_array_ops.tile(input, ops.convert_to_tensor(multiples), name);
 
         public Tensor tile(Tensor input, Shape multiples, string name = null) 
         {

src/TensorFlowNET.Core/Attributes/c_api.ops.cs

@@ -57,6 +57,21 @@ public partial class c_api
         [DllImport(TensorFlowLibName)]
         public static extern int TF_OperationGetAttrValueProto(IntPtr oper, string attr_name, SafeBufferHandle output_attr_value, SafeStatusHandle status);
 
+        [DllImport(TensorFlowLibName)]
+        public static extern void TF_OperationGetAttrType(IntPtr oper, string attr_name, IntPtr value, SafeStatusHandle status);
+
+        [DllImport(TensorFlowLibName)]
+        public static extern void TF_OperationGetAttrInt(IntPtr oper, string attr_name, IntPtr value, SafeStatusHandle status);
+
+        [DllImport(TensorFlowLibName)]
+        public static extern void TF_OperationGetAttrFloat(IntPtr oper, string attr_name, IntPtr value, SafeStatusHandle status);
+
+        [DllImport(TensorFlowLibName)]
+        public static extern void TF_OperationGetAttrBool(IntPtr oper, string attr_name, IntPtr value, SafeStatusHandle status);
+
+        [DllImport(TensorFlowLibName)]
+        public static extern void TF_OperationGetAttrShape(IntPtr oper, string attr_name, long[] value, int num_dims, SafeStatusHandle status);
+
         [DllImport(TensorFlowLibName)]
         public static extern void TF_SetAttrBool(IntPtr desc, string attr_name, bool value);
 

src/TensorFlowNET.Core/Clustering/_InitializeClustersOpFactory.cs

@@ -88,7 +88,7 @@ private Tensor _initialize()
 
         public Tensor op()
         {
-            var x = control_flow_ops.cond(gen_math_ops.equal(_num_remaining, 0),
+            var x = control_flow_ops.cond(gen_math_ops.equal(_num_remaining, ops.convert_to_tensor(0)),
                 () =>
                 {
                     return check_ops.assert_equal(_cluster_centers_initialized, true);