Allow object[] to be shape parameters.

Author: Oceania2018

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

@@ -78,15 +78,15 @@ public Tensor check_numerics(Tensor tensor, string message, string name = null)
         /// <param name="axis"></param>
         /// <param name="name"></param>
         /// <returns>A `Tensor` resulting from concatenation of the input tensors.</returns>
-        public Tensor concat(IList<Tensor> values, int axis, string name = "concat")
+        public Tensor concat(IEnumerable<Tensor> values, int axis, string name = "concat")
         {
-            if (values.Count == 1)
+            if (values.Count() == 1)
             {
                 return tf_with(ops.name_scope(name), scope =>
                 {
                     var tensor = ops.convert_to_tensor(axis, name: "concat_dim", dtype: dtypes.int32);
                     Debug.Assert(tensor.TensorShape.ndim == 0);
-                    return identity(values[0], name: scope);
+                    return identity(values.First(), name: scope);
                 });
             }
 

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

@@ -19,15 +19,18 @@ namespace Tensorflow
     public partial class tensorflow
     {
         public Tensor reshape(Tensor tensor,
-            TensorShape shape,
-            string name = null) => gen_array_ops.reshape(tensor, shape, name);
+                TensorShape shape,
+                string name = null) 
+            => gen_array_ops.reshape(tensor, shape, name);
 
         public Tensor reshape(Tensor tensor,
-            Tensor[] shape,
-            string name = null) => gen_array_ops.reshape(tensor, shape, name);
+                Tensor shape,
+                string name = null) 
+            => gen_array_ops.reshape(tensor, shape, name);
 
         public Tensor reshape(Tensor tensor,
-                Tensor shape,
-                string name = null) => gen_array_ops.reshape(tensor, shape, name);
+                object[] shape,
+                string name = null)
+            => gen_array_ops.reshape(tensor, shape, name);
     }
 }

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

@@ -13,13 +13,22 @@ You may obtain a copy of the License at
    See the License for the specific language governing permissions and
    limitations under the License.
 ******************************************************************************/
+using static Tensorflow.Binding;
 
 namespace Tensorflow
 {
     public partial class tensorflow
     {
-        public Tensor tile<T>(Tensor input,
-                T multiples,
-                string name = null) => gen_array_ops.tile(input, multiples, name);
+        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);
+
+        public Tensor tile(Tensor input, TensorShape multiples, string name = null) 
+        {
+            var multiples_tensor = constant_op.constant(multiples);
+            return gen_array_ops.tile(input, multiples_tensor, name);
+        } 
     }
 }

src/TensorFlowNET.Core/Contexts/Context.AutoMode.cs

@@ -28,16 +28,27 @@ namespace Tensorflow.Contexts
     /// </summary>
     public sealed partial class Context
     {
-        // [DebuggerStepThrough]
-        public T RunInAutoMode<T>(Func<T> graphAction, Func<T> eagerAction, params Tensor[] tensors)
+        public T RunInAutoMode<T>(Func<T> graphAction, Func<T> eagerAction, params object[] args)
         {
-            var shouldRunInEager = executing_eagerly()
-                && tensors.Count(x => x.IsEagerTensor) == tensors.Length;
-
-            if (shouldRunInEager)
-                return eagerAction();
-            else
+            if (tf.Context.has_graph_arg(args))
+            {
                 return graphAction();
+            }
+            else
+            {
+                try
+                {
+                    return eagerAction();
+                }
+                catch (InvalidArgumentError ex)
+                {
+                    throw ex;
+                }
+                catch (Exception ex)
+                {
+                    return graphAction();
+                }
+            }
         }
 
         // [DebuggerStepThrough]
@@ -46,12 +57,7 @@ public Tensors RunInAutoMode2(Func<Tensors> graphAction,
             Action<Operation> recordGradient,
             Tensors tensors)
         {
-            var shouldRunInEager = executing_eagerly()
-                && tensors.Count(x => x.IsEagerTensor) == tensors.Length;
-
-            if (shouldRunInEager)
-                return eagerAction();
-            else
+            if (tf.Context.has_graph_arg(tensors))
             {
                 if (executing_eagerly())
                 {
@@ -68,6 +74,10 @@ public Tensors RunInAutoMode2(Func<Tensors> graphAction,
                     return result;
                 }
             }
+            else
+            {
+                return eagerAction();
+            }
         }
     }
 }

src/TensorFlowNET.Core/Contexts/Context.cs

@@ -20,6 +20,7 @@ limitations under the License.
 using Tensorflow.Eager;
 using static Tensorflow.Binding;
 using Google.Protobuf;
+using Tensorflow.Util;
 
 namespace Tensorflow.Contexts
 {
@@ -103,6 +104,29 @@ public void graph_mode(bool isFunc = false)
         public void eager_mode(bool isFunc = false)
             => context_switches.Push(true, isFunc);
 
+        public bool switched_to_graph(params object[] args)
+        {
+            var switching_to_graph = has_graph_arg(args) && tf.Context.executing_eagerly();
+            if (switching_to_graph)
+                tf.Context.graph_mode(tf.Context.is_build_function());
+            return switching_to_graph;
+        }
+
+        public bool has_graph_arg(params object[] args)
+        {
+            var flatten_args = nest.flatten<object>(args);
+            bool has_graph_arg = false;
+            foreach (var el in flatten_args)
+            {
+                if (el is Tensor tensor && !tensor.IsEagerTensor)
+                {
+                    has_graph_arg = true;
+                    break;
+                }
+            }
+            return has_graph_arg;
+        }
+
         public void restore_mode()
         {
             context_switches.Pop();

src/TensorFlowNET.Core/Eager/EagerRunner.RecordGradient.cs

@@ -38,9 +38,9 @@ public bool RecordGradient(string op_name,
                     }
                 }*/
             }
-
-            tf.Logger.Debug($"RecordGradient: should_record={should_record}, op_name={op_name}");
+            
             if (!should_record) return should_record;
+            tf.Logger.Debug($"RecordGradient: op_name={op_name}");
 
             Tensor[] op_outputs;
 #pragma warning disable CS0219 // Variable is assigned but its value is never used

src/TensorFlowNET.Core/Eager/EagerRunner.TFE_FastPathExecute.cs

@@ -50,7 +50,7 @@ public Tensor[] TFE_FastPathExecute(Context ctx,
 
             var op_def = tf.get_default_graph().GetOpDef(opName);
 
-            var flattened_attrs = new List<object>(op_def.InputArg.Count);
+            var flattened_attrs = new List<object>(op_def.Attr.Count * 2);
             var flattened_inputs = new List<Tensor>(op_def.InputArg.Count);
 
             // Set non-inferred attrs, including setting defaults if the attr is passed in
@@ -221,23 +221,9 @@ bool AddInputToOp(object inputs,
             SafeTensorHandleHandle input_handle;
 
             // ConvertToTensor();
-            switch (inputs)
-            {
-                case EagerTensor input:
-                    input_handle = input.EagerTensorHandle;
-                    flattened_inputs.Add(input);
-                    break;
-                case ResourceVariable variable:
-                    var var_tensor = variable.AsTensor();
-                    input_handle = var_tensor.EagerTensorHandle;
-                    flattened_inputs.Add(var_tensor);
-                    break;
-                default:
-                    var tensor = tf.convert_to_tensor(inputs);
-                    input_handle = tensor.EagerTensorHandle;
-                    flattened_inputs.Add(tensor);
-                    break;
-            }
+            var tensor = tf.convert_to_tensor(inputs);
+            input_handle = tensor.EagerTensorHandle;
+            flattened_inputs.Add(tensor);
 
             if (add_type_attr && !string.IsNullOrEmpty(input_arg.TypeAttr))
             {

src/TensorFlowNET.Core/Framework/tensor_shape.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Linq;
 using System.Text;
+using static Tensorflow.Binding;
 
 namespace Tensorflow.Framework
 {
@@ -65,5 +66,17 @@ public static int dimension_value(Dimension dimension)
 
         public static TensorShape as_shape(this Shape shape)
              => new TensorShape(shape.Dimensions);
+
+        public static TensorShape most_specific_compatible_shape(this TensorShape self, TensorShape other)
+        {
+            var dims = range(self.rank).Select(x => -1).ToArray();
+            foreach(var (i, (d1, d2)) in enumerate(zip(self.dims, other.dims)))
+            {
+                if (d1 == d2)
+                    dims[i] = d1;
+            }
+
+            return new TensorShape(dims);
+        }
     }
 }

src/TensorFlowNET.Core/Functions/ConcreteFunction.cs

@@ -134,7 +134,7 @@ public Tensors FilteredCall(Tensors inputs)
         /// <param name="args"></param>
         /// <param name="captured_inputs"></param>
         /// <returns></returns>
-        public Tensor[] CallFlat(Tensor[] args, Tensor[] captured_inputs)
+        public Tensors CallFlat(Tensor[] args, Tensor[] captured_inputs)
         {
             var executing_eagerly = tf.Context.executing_eagerly();
             var default_graph = ops.get_default_graph();

src/TensorFlowNET.Core/Functions/TapeGradientFunctions.cs

@@ -99,8 +99,18 @@ public void Record(Tensors flat_outputs, Tensors inference_args)
                     if (input_index >= backward_function_inputs)
                         break;
                 }
+
                 tf.Logger.Debug($"Invoke backward function: {backward.Name}");
-                return backward.CallFlat(processed_args, remapped_captures);
+                var gradients = backward.CallFlat(processed_args, remapped_captures);
+
+                foreach (var unneeded_gradient_index in unneeded_gradients)
+                {
+                    var index = Convert.ToInt32(unneeded_gradient_index);
+                    if (gradients.Length <= index)
+                        gradients.Insert(index, null);
+                }
+
+                return gradients;
             };
 
             return (_backward_function_wrapper, recorded_outputs);