Remove Range class due to conflict with .net 5.

src/TensorFlowNET.Core/Operations/Operation.Implicit.cs

@@ -31,8 +31,6 @@ namespace Tensorflow
             => op._handle;
         public static implicit operator Tensor(Operation op)
             => op.output;
-        public static implicit operator RefVariable(Operation op)
-            => new RefVariable(op);
 
         public override string ToString()
         {

src/TensorFlowNET.Core/Operations/embedding_ops.cs

@@ -21,37 +21,6 @@ namespace Tensorflow
 {
     public class embedding_ops
     {
-        /// <summary>
-        /// Helper function for embedding_lookup and _compute_sampled_logits.
-        /// </summary>
-        /// <param name="params"></param>
-        /// <param name="ids"></param>
-        /// <param name="partition_strategy"></param>
-        /// <param name="name"></param>
-        /// <returns></returns>
-        public static Tensor _embedding_lookup_and_transform(RefVariable @params,
-                Tensor ids,
-                string partition_strategy = "mod",
-                string name = null,
-                string max_norm = null)
-        {
-            return tf_with(ops.name_scope(name, "embedding_lookup", new { @params, ids }), scope =>
-            {
-                name = scope;
-                int np = 1;
-                ids = ops.convert_to_tensor(ids, name: "ids");
-                if (np == 1)
-                {
-                    var gather = array_ops.gather(@params, ids, name: name);
-                    var result = _clip(gather, ids, max_norm);
-
-                    return array_ops.identity(result);
-                }
-
-                throw new NotImplementedException("_embedding_lookup_and_transform");
-            });
-        }
-
         /// <summary>
         /// Helper function for embedding_lookup and _compute_sampled_logits.
         /// </summary>

src/TensorFlowNET.Keras/Engine/Model.Compile.cs

@@ -10,9 +10,16 @@ namespace Tensorflow.Keras.Engine
         LossesContainer compiled_loss;
         MetricsContainer compiled_metrics;
 
-        public void compile(ILossFunc loss, OptimizerV2 optimizer, string[] metrics)
+        public void compile(OptimizerV2 optimizer = null, 
+            ILossFunc loss = null, 
+            string[] metrics = null)
         {
-            this.optimizer = optimizer;
+            this.optimizer = optimizer ?? new RMSprop(new RMSpropArgs
+            {
+            });
+
+            this.loss = loss ?? new MeanSquaredError();
+
             compiled_loss = new LossesContainer(loss, output_names: output_names);
             compiled_metrics = new MetricsContainer(metrics, output_names: output_names);
 
@@ -22,7 +29,6 @@ namespace Tensorflow.Keras.Engine
             // Initialize cache attrs.
             _reset_compile_cache();
             _is_compiled = true;
-            this.loss = loss;
         }
 
         public void compile(string optimizer, string loss, string[] metrics)

src/TensorFlowNET.Keras/Layers/LayersApi.cs

@@ -518,6 +518,18 @@ namespace Tensorflow.Keras.Layers
             return input_layer.InboundNodes[0].Outputs;
         }
 
+        public InputLayer InputLayer(TensorShape input_shape,
+            string name = null,
+            bool sparse = false,
+            bool ragged = false)
+            => new InputLayer(new InputLayerArgs
+            {
+                InputShape = input_shape,
+                Name = name,
+                Sparse = sparse,
+                Ragged = ragged
+            });
+
         /// <summary>
         /// Max pooling operation for 1D temporal data.
         /// </summary>

src/TensorFlowNet.Benchmarks/Tensorflow.Benchmark.csproj

@@ -36,7 +36,7 @@
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
-    <PackageReference Include="SciSharp.TensorFlow.Redist-Windows-GPU" Version="2.3.1" />
+    <PackageReference Include="SciSharp.TensorFlow.Redist-Windows-GPU" Version="2.5.0" />
   </ItemGroup>
 
   <ItemGroup>

test/TensorFlowNET.Keras.UnitTest/Layers/LayersTest.cs

@@ -1,7 +1,8 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using NumSharp;
+using System.Collections.Generic;
 using Tensorflow;
-using Tensorflow.Operations.Initializers;
+using Tensorflow.Keras;
 using static Tensorflow.Binding;
 using static Tensorflow.KerasApi;
 
@@ -13,6 +14,18 @@ namespace TensorFlowNET.Keras.UnitTest
     [TestClass]
     public class LayersTest : EagerModeTestBase
     {
+        // [TestMethod]
+        public void InputLayer()
+        {
+            var model = keras.Sequential(new List<ILayer>
+            {
+              keras.layers.InputLayer(input_shape: 4),
+              keras.layers.Dense(8)
+            });
+            model.compile(optimizer: keras.optimizers.RMSprop(0.001f));
+            model.fit(np.zeros((10, 4)), np.ones((10, 8)));
+        }
+
         [TestMethod]
         public void Sequential()
         {

test/TensorFlowNET.Keras.UnitTest/Range.cs

@@ -1,234 +0,0 @@
-// https://github.com/dotnet/corefx/blob/1597b894a2e9cac668ce6e484506eca778a85197/src/Common/src/CoreLib/System/Index.cs
-// https://github.com/dotnet/corefx/blob/1597b894a2e9cac668ce6e484506eca778a85197/src/Common/src/CoreLib/System/Range.cs
-
-using System.Runtime.CompilerServices;
-
-namespace System
-{
-    /// <summary>Represent a type can be used to index a collection either from the start or the end.</summary>
-    /// <remarks>
-    /// Index is used by the C# compiler to support the new index syntax
-    /// <code>
-    /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 } ;
-    /// int lastElement = someArray[^1]; // lastElement = 5
-    /// </code>
-    /// </remarks>
-    public readonly struct Index : IEquatable<Index>
-    {
-        private readonly int _value;
-
-        /// <summary>Construct an Index using a value and indicating if the index is from the start or from the end.</summary>
-        /// <param name="value">The index value. it has to be zero or positive number.</param>
-        /// <param name="fromEnd">Indicating if the index is from the start or from the end.</param>
-        /// <remarks>
-        /// If the Index constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element.
-        /// </remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Index(int value, bool fromEnd = false)
-        {
-            if (value < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative");
-            }
-
-            if (fromEnd)
-                _value = ~value;
-            else
-                _value = value;
-        }
-
-        // The following private constructors mainly created for perf reason to avoid the checks
-        private Index(int value)
-        {
-            _value = value;
-        }
-
-        /// <summary>Create an Index pointing at first element.</summary>
-        public static Index Start => new Index(0);
-
-        /// <summary>Create an Index pointing at beyond last element.</summary>
-        public static Index End => new Index(~0);
-
-        /// <summary>Create an Index from the start at the position indicated by the value.</summary>
-        /// <param name="value">The index value from the start.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Index FromStart(int value)
-        {
-            if (value < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative");
-            }
-
-            return new Index(value);
-        }
-
-        /// <summary>Create an Index from the end at the position indicated by the value.</summary>
-        /// <param name="value">The index value from the end.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Index FromEnd(int value)
-        {
-            if (value < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(value), "value must be non-negative");
-            }
-
-            return new Index(~value);
-        }
-
-        /// <summary>Returns the index value.</summary>
-        public int Value
-        {
-            get
-            {
-                if (_value < 0)
-                {
-                    return ~_value;
-                }
-                else
-                {
-                    return _value;
-                }
-            }
-        }
-
-        /// <summary>Indicates whether the index is from the start or the end.</summary>
-        public bool IsFromEnd => _value < 0;
-
-        /// <summary>Calculate the offset from the start using the giving collection length.</summary>
-        /// <param name="length">The length of the collection that the Index will be used with. length has to be a positive value</param>
-        /// <remarks>
-        /// For performance reason, we don't validate the input length parameter and the returned offset value against negative values.
-        /// we don't validate either the returned offset is greater than the input length.
-        /// It is expected Index will be used with collections which always have non negative length/count. If the returned offset is negative and
-        /// then used to index a collection will get out of range exception which will be same affect as the validation.
-        /// </remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public int GetOffset(int length)
-        {
-            var offset = _value;
-            if (IsFromEnd)
-            {
-                // offset = length - (~value)
-                // offset = length + (~(~value) + 1)
-                // offset = length + value + 1
-
-                offset += length + 1;
-            }
-            return offset;
-        }
-
-        /// <summary>Indicates whether the current Index object is equal to another object of the same type.</summary>
-        /// <param name="value">An object to compare with this object</param>
-        public override bool Equals(object? value) => value is Index && _value == ((Index)value)._value;
-
-        /// <summary>Indicates whether the current Index object is equal to another Index object.</summary>
-        /// <param name="other">An object to compare with this object</param>
-        public bool Equals(Index other) => _value == other._value;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        public override int GetHashCode() => _value;
-
-        /// <summary>Converts integer number to an Index.</summary>
-        public static implicit operator Index(int value) => FromStart(value);
-
-        /// <summary>Converts the value of the current Index object to its equivalent string representation.</summary>
-        public override string ToString()
-        {
-            if (IsFromEnd)
-                return "^" + ((uint)Value).ToString();
-
-            return ((uint)Value).ToString();
-        }
-    }
-
-    /// <summary>Represent a range has start and end indexes.</summary>
-    /// <remarks>
-    /// Range is used by the C# compiler to support the range syntax.
-    /// <code>
-    /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 };
-    /// int[] subArray1 = someArray[0..2]; // { 1, 2 }
-    /// int[] subArray2 = someArray[1..^0]; // { 2, 3, 4, 5 }
-    /// </code>
-    /// </remarks>
-    public readonly struct Range : IEquatable<Range>
-    {
-        /// <summary>Represent the inclusive start index of the Range.</summary>
-        public Index Start { get; }
-
-        /// <summary>Represent the exclusive end index of the Range.</summary>
-        public Index End { get; }
-
-        /// <summary>Construct a Range object using the start and end indexes.</summary>
-        /// <param name="start">Represent the inclusive start index of the range.</param>
-        /// <param name="end">Represent the exclusive end index of the range.</param>
-        public Range(Index start, Index end)
-        {
-            Start = start;
-            End = end;
-        }
-
-        /// <summary>Indicates whether the current Range object is equal to another object of the same type.</summary>
-        /// <param name="value">An object to compare with this object</param>
-        public override bool Equals(object? value) =>
-            value is Range r &&
-            r.Start.Equals(Start) &&
-            r.End.Equals(End);
-
-        /// <summary>Indicates whether the current Range object is equal to another Range object.</summary>
-        /// <param name="other">An object to compare with this object</param>
-        public bool Equals(Range other) => other.Start.Equals(Start) && other.End.Equals(End);
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        public override int GetHashCode()
-        {
-            return Start.GetHashCode() * 31 + End.GetHashCode();
-        }
-
-        /// <summary>Converts the value of the current Range object to its equivalent string representation.</summary>
-        public override string ToString()
-        {
-            return Start + ".." + End;
-        }
-
-        /// <summary>Create a Range object starting from start index to the end of the collection.</summary>
-        public static Range StartAt(Index start) => new Range(start, Index.End);
-
-        /// <summary>Create a Range object starting from first element in the collection to the end Index.</summary>
-        public static Range EndAt(Index end) => new Range(Index.Start, end);
-
-        /// <summary>Create a Range object starting from first element to the end.</summary>
-        public static Range All => new Range(Index.Start, Index.End);
-
-        /// <summary>Calculate the start offset and length of range object using a collection length.</summary>
-        /// <param name="length">The length of the collection that the range will be used with. length has to be a positive value.</param>
-        /// <remarks>
-        /// For performance reason, we don't validate the input length parameter against negative values.
-        /// It is expected Range will be used with collections which always have non negative length/count.
-        /// We validate the range is inside the length scope though.
-        /// </remarks>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public (int Offset, int Length) GetOffsetAndLength(int length)
-        {
-            int start;
-            var startIndex = Start;
-            if (startIndex.IsFromEnd)
-                start = length - startIndex.Value;
-            else
-                start = startIndex.Value;
-
-            int end;
-            var endIndex = End;
-            if (endIndex.IsFromEnd)
-                end = length - endIndex.Value;
-            else
-                end = endIndex.Value;
-
-            if ((uint)end > (uint)length || (uint)start > (uint)end)
-            {
-                throw new ArgumentOutOfRangeException(nameof(length));
-            }
-
-            return (start, end - start);
-        }
-    }
-}

test/TensorFlowNET.Keras.UnitTest/RuntimeHelpers.cs

@@ -1,39 +0,0 @@
-namespace System.Runtime.CompilerServices
-{
-    internal static class RuntimeHelpers
-    {
-        /// <summary>
-        /// Slices the specified array using the specified range.
-        /// </summary>
-        public static T[] GetSubArray<T>(T[] array, Range range)
-        {
-            if (array == null)
-            {
-                throw new ArgumentNullException(nameof(array));
-            }
-
-            (int offset, int length) = range.GetOffsetAndLength(array.Length);
-
-            if (default(T) != null || typeof(T[]) == array.GetType())
-            {
-                // We know the type of the array to be exactly T[].
-
-                if (length == 0)
-                {
-                    return Array.Empty<T>();
-                }
-
-                var dest = new T[length];
-                Array.Copy(array, offset, dest, 0, length);
-                return dest;
-            }
-            else
-            {
-                // The array is actually a U[] where U:T.
-                var dest = (T[])Array.CreateInstance(array.GetType().GetElementType(), length);
-                Array.Copy(array, offset, dest, 0, length);
-                return dest;
-            }
-        }
-    }
-}