Merge branch 'master' of https://github.com/SciSharp/TensorFlow.NET

Author: NiklasGustafsson

README.md

@@ -9,7 +9,7 @@
 [![Badge](https://img.shields.io/badge/link-996.icu-red.svg)](https://996.icu/#/en_US)
 [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/javiercp/BinderTF.NET/master?urlpath=lab)
 
-*master branch is based on tensorflow 2.3 now, v0.15-tensorflow1.15 is from tensorflow1.15.*
+*master branch is based on tensorflow v2.4, v0.3x branch is based on tensorflow v2.3, v0.15-tensorflow1.15 is from tensorflow1.15.*
 
 
 ![tensors_flowing](docs/assets/tensors_flowing.gif)
@@ -30,7 +30,8 @@ Go through the online docs [TensorFlow for .NET](https://scisharp.github.io/tens
 
 | TensorFlow                 | tf native1.14, cuda 10.0 | tf native 1.15, cuda 10.0 | tf native 2.3, cuda 10.1 | tf native 2.4, cuda 11 |
 | -------------------------- | ------------- | -------------- | ------------- | ------------- |
-| tf.net 0.3x, tf.keras 0.2 |               |                | x | not compatible |
+| tf.net 0.4x, tf.keras 0.5 |  |  |  | x |
+| tf.net 0.3x, tf.keras 0.4 |               |                | x |  |
 | tf.net 0.2x          |               | x | x |              |
 | tf.net 0.15          | x | x |               |               |
 | tf.net 0.14          | x |                |               |               |
@@ -50,10 +51,10 @@ PM> Install-Package TensorFlow.Keras
 
 ### Install tensorflow binary
 ### For CPU version
-PM> Install-Package SciSharp.TensorFlow.Redist -Version 2.3.1
+PM> Install-Package SciSharp.TensorFlow.Redist
 
 ### For GPU version (CUDA and cuDNN are required)
-PM> Install-Package SciSharp.TensorFlow.Redist-Windows-GPU -Version 2.3.1
+PM> Install-Package SciSharp.TensorFlow.Redist-Windows-GPU
 ```
 
 Import TF.NET and Keras API in your project.

src/TensorFlowNET.Console/MemoryBasicTest.cs

@@ -112,16 +112,18 @@ 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(tf.Context, tf.Context.DeviceName,
-                    "Conv2D", null,
-                    null,
-                    input, filter,
-                    "strides", strides,
-                    "use_cudnn_on_gpu", true,
-                    "padding", "VALID",
-                    "explicit_paddings", new int[0],
-                    "data_format", "NHWC",
-                    "dilations", dilations);
+                var results = tf.Runner.TFE_FastPathExecute(new FastPathOpExecInfo("Conv2D", null, input, filter)
+                {
+                    attrs = ConvertToDict(new
+                    {
+                        strides,
+                        use_cudnn_on_gpu = true,
+                        padding = "VALID",
+                        explicit_paddings = new int[0],
+                        data_format = "NHWC",
+                        dilations
+                    })
+                });
             };
 
         public Action<int, int> Conv2DWithVariable
@@ -132,16 +134,18 @@ 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(tf.Context, tf.Context.DeviceName,
-                    "Conv2D", null,
-                    null,
-                    input, filter,
-                    "strides", strides,
-                    "use_cudnn_on_gpu", true,
-                    "padding", "VALID",
-                    "explicit_paddings", new int[0],
-                    "data_format", "NHWC",
-                    "dilations", dilations);
+                var results = tf.Runner.TFE_FastPathExecute(new FastPathOpExecInfo("Conv2D", null, input, filter)
+                {
+                    attrs = ConvertToDict(new
+                    {
+                        strides,
+                        use_cudnn_on_gpu = true,
+                        padding = "VALID",
+                        explicit_paddings = new int[0],
+                        data_format = "NHWC",
+                        dilations
+                    })
+                });
             };
 
         public Action<int, int> Dataset

src/TensorFlowNET.Console/Tensorflow.Console.csproj

@@ -11,6 +11,7 @@
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
     <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <PlatformTarget>x64</PlatformTarget>
   </PropertyGroup>
 
   <ItemGroup>

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

@@ -13,6 +13,7 @@ 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
 {
@@ -37,8 +38,8 @@ public Tensor diag(Tensor diagonal, string name = null)
             public Tensor matmul(Tensor a, Tensor b)
                 => math_ops.matmul(a, b);
 
-            public Tensor batch_matmul(Tensor x, Tensor y)
-                => gen_math_ops.batch_mat_mul(x, y);
+            public Tensor batch_matmul(Tensor x, Tensor y, bool adj_x = false, bool adj_y = false, string name = null)
+                => math_ops.batch_matmul(x, y, adj_x: adj_x, adj_y: adj_y, name: name);
         }
 
         public Tensor diag(Tensor diagonal, string name = null)
@@ -47,7 +48,32 @@ public Tensor diag(Tensor diagonal, string name = null)
         public Tensor matmul(Tensor a, Tensor b)
             => math_ops.matmul(a, b);
 
-        public Tensor batch_matmul(Tensor x, Tensor y)
-            => gen_math_ops.batch_mat_mul(x, y);
+        /// <summary>
+        /// Multiply slices of the two matrices "x" and "y".
+        /// </summary>
+        /// <remarks>
+        /// The `BatchMatMul` operation is embedded into the
+        /// `MatMul` operation on the DLL side. However the expected
+        /// attributes are not the same, hence we need to expose this
+        /// method to have the right args list on the `_apply_op_helper`
+        /// function.
+        ///
+        /// For each rank > 2 the first rank - 2 dimensions are considered
+        /// as fixed, and have to be consistent across the two matrices. A
+        /// common matrix multiplication is then applied over the residual
+        /// 2 dimensions.
+        ///
+        /// e.g.
+        ///     x is (3, 6, 12); y is (3, 12, 6)
+        ///     batch_matmul(x, y) ==> (3, 6, 6)
+        /// </remarks>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="adj_x"></param>
+        /// <param name="adj_y"></param>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public Tensor batch_matmul(Tensor x, Tensor y, bool adj_x = false, bool adj_y = false, string name = null)
+            => math_ops.batch_matmul(x, y, adj_x: adj_x, adj_y: adj_y, name: name);
     }
 }

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

@@ -32,6 +32,28 @@ public Tensor log(Tensor x, string name = null)
             /// <returns></returns>
             public Tensor erf(Tensor x, string name = null)
                 => math_ops.erf(x, name);
+
+            /// <summary>
+            /// 
+            /// </summary>
+            /// <param name="arr"></param>
+            /// <param name="weights"></param>
+            /// <param name="minlength"></param>
+            /// <param name="maxlength"></param>
+            /// <param name="dtype"></param>
+            /// <param name="name"></param>
+            /// <param name="axis"></param>
+            /// <param name="binary_output"></param>
+            /// <returns></returns>
+            public Tensor bincount(Tensor arr, Tensor weights = null,
+                Tensor minlength = null,
+                Tensor maxlength = null,
+                TF_DataType dtype = TF_DataType.TF_INT32,
+                string name = null,
+                TensorShape axis = null,
+                bool binary_output = false)
+                => math_ops.bincount(arr, weights: weights, minlength: minlength, maxlength: maxlength,
+                    dtype: dtype, name: name, axis: axis, binary_output: binary_output);
         }
 
         public Tensor abs(Tensor x, string name = null)

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

@@ -93,7 +93,12 @@ public Tensor random_shuffle(Tensor value, int? seed = null, string name = null)
             => random_ops.random_shuffle(value, seed: seed, name: name);
 
         public void set_random_seed(int seed)
-            => ops.get_default_graph().seed = seed;
+        {
+            if (executing_eagerly())
+                Context.set_global_seed(seed);
+            else
+                ops.get_default_graph().seed = seed;
+        }
 
         public Tensor multinomial(Tensor logits, int num_samples, int? seed = null,
             string name = null, TF_DataType output_dtype = TF_DataType.DtInvalid)

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

@@ -14,17 +14,18 @@ You may obtain a copy of the License at
    limitations under the License.
 ******************************************************************************/
 
+using System;
 using Tensorflow.Framework;
 
 namespace Tensorflow
 {
     public partial class tensorflow
     {
-        public SparseTensor<T> SparseTensor<T>(long[,] indices, T[] values, long[] dense_shape)
-            => new SparseTensor<T>(indices, values, dense_shape);
+        public SparseTensor SparseTensor(long[,] indices, Array values, long[] dense_shape)
+            => new SparseTensor(indices, values, dense_shape);
 
-        public Tensor sparse_tensor_to_dense<T>(SparseTensor<T> sp_input,
-            T default_value = default,
+        public Tensor sparse_tensor_to_dense(SparseTensor sp_input,
+            Array default_value = default,
             bool validate_indices = true,
             string name = null)
             => gen_sparse_ops.sparse_to_dense(sp_input.indices,

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

@@ -14,6 +14,8 @@ You may obtain a copy of the License at
    limitations under the License.
 ******************************************************************************/
 
+using Tensorflow.Framework;
+
 namespace Tensorflow
 {
     public partial class tensorflow
@@ -64,6 +66,27 @@ public Tensor substr(Tensor input, int pos, int len,
             public Tensor substr(string input, int pos, int len,
                     string name = null, string @uint = "BYTE")
                 => ops.substr(input, pos, len, @uint: @uint, name: name);
+
+            /// <summary>
+            /// String lengths of `input`.
+            /// </summary>
+            /// <param name="input"></param>
+            /// <param name="name"></param>
+            /// <param name="unit"></param>
+            /// <returns></returns>
+            public Tensor string_length(Tensor input, string name = null, string unit = "BYTE")
+                => ops.string_length(input, name: name, unit: unit);
+
+            public RaggedTensor split(Tensor input, string sep = "", int maxsplit = -1, string name = null)
+                => ops.string_split_v2(input, sep: sep, maxsplit : maxsplit, name : name);
+
+            public (RaggedTensor, RaggedTensor) unicode_decode_with_offsets(Tensor input, string input_encoding, 
+                string errors = "replace", int replacement_char = 0xFFFD, 
+                bool replace_control_characters = false, string name = null)
+                => ops.unicode_decode_with_offsets(input, input_encoding, errors,
+                    replacement_char: replacement_char,
+                    replace_control_characters: replace_control_characters,
+                    name: name);
         }
     }
 }

src/TensorFlowNET.Core/Contexts/AutoModeArgs.cs

@@ -30,67 +30,35 @@ namespace Tensorflow.Contexts
     public sealed partial class Context
     {
         // [DebuggerStepThrough]
-        public T RunInAutoMode<T>(Func<T> graphAction, Func<T> eagerAction, params object[] args)
+        public Tensors ExecuteOp(string OpType, string Name, ExecuteOpArgs args)
         {
-            if (tf.Context.has_graph_arg(args))
+            Func<Tensors> graphAction = () =>
             {
-                if (executing_eagerly())
-                {
-                    graph_mode();
-                    var result = graphAction();
-                    restore_mode();
-                    return result;
-                }
-                else
-                {
-                    return graphAction();
-                }
-            }
-            else
-            {
-                if (tf.Context.executing_eagerly())
+                var keywords = new Dictionary<string, object>();
+                if(args.OpInputArgs != null)
                 {
-                    return eagerAction();
+                    foreach (var (i, input) in enumerate(args.OpInputArgs))
+                        keywords[$"input_{i}"] = input;
                 }
-                else
+
+                if(args.OpAttrs != null)
                 {
-                    return graphAction();
+                    foreach (var attr in args.OpAttrs)
+                        keywords[attr.Key] = attr.Value;
                 }
-            }
-        }
-        
-        // [DebuggerStepThrough]
-        public Tensors RunInAutoMode2(string OpType, string Name, AutoModeArgs args)
-        {
-            var inputArgs = ConvertToDict(args.OpInputArgs);
-            var attrDict = ConvertToDict(args.OpAttrs);
-            
-            Func<Tensor> graphAction = () =>
-            {
-                foreach (var attr in attrDict)
-                    inputArgs[attr.Key] = attr.Value;
-                return tf.OpDefLib._apply_op_helper(OpType, Name, inputArgs).output;
+
+                return tf.OpDefLib._apply_op_helper(OpType, Name, keywords).outputs;
             };
 
-            Func<Tensor> eagerAction = () =>
+            Func<Tensors> eagerAction = () =>
             {
-                var attrs = new object[attrDict.Count() * 2];
-                int i = 0;
-                foreach(var arg in attrDict)
+                return tf.Runner.TFE_FastPathExecute(new FastPathOpExecInfo(OpType, Name, args.OpInputArgs)
                 {
-                    attrs[i]= arg.Key;
-                    attrs[i + 1] = arg.Value;
-                    i += 2;
-                }    
-
-                return tf.Runner.TFE_FastPathExecute2(tf.Context, tf.Context.DeviceName,
-                    OpType, Name,
-                    null,
-                    inputArgs.Values.ToArray(), 
-                    attrs).FirstOrDefault();
+                    attrs = args.OpAttrs
+                });
             };
 
-            if (tf.Context.has_graph_arg(inputArgs.Values))
+            if (tf.Context.has_graph_arg(args.OpInputArgs))
             {
                 if (executing_eagerly())
                 {