Merge pull request #1331 from NiklasGustafsson/missing

Support creating tensors from a Memory<T> instance.

Author: NiklasGustafsson

RELEASENOTES.md

@@ -6,8 +6,12 @@ Releases, starting with 9/2/2021, are listed with the most recent release at the
 
 __Breaking Changes__:
 
+When creating a tensor from a 1-D array, and passing in a shape, there is now an ambiguity between the IList and Memory overloads of `torch.tensor()`. The ambiguity is resolved by removing the `dimensions` argument if it is redundant, or by an explicit cast to IList if it is not.
+
 __API Changes__:
 
+ #1326 Allow arrays used to create tensors to be larger than the tensor. Create tensors from a Memory instance<br/>
+
 __Bug Fixes__:
 
 

src/TorchSharp/Tensor/Factories/Tensor.Factories.cs

@@ -134,7 +134,7 @@ public static Tensor normal(double mean, double std, ReadOnlySpan<long> size, Sc
         /// <returns>A constructed tensor with elements of `dtype`</returns>
         /// <exception cref="ArgumentException"></exception>
         private static Tensor _tensor_generic(Array rawArray, ReadOnlySpan<long> dimensions, sbyte origType, ScalarType? dtype, Device? device, bool requires_grad, bool clone = true, string[]? names = null)
-        {
+        {           
             {
                 // Validate the sizes before handing over storage to native code...
                 var prod = 1L;
@@ -164,6 +164,68 @@ private static Tensor _tensor_generic(Array rawArray, ReadOnlySpan<long> dimensi
             dtype = dtype.HasValue ? dtype : (ScalarType)origType;
 
             unsafe {
+                void *ptr = null;
+                IntPtr iPtr = (IntPtr)ptr;
+
+                fixed (long* shape = dimensions) {
+                    var handle = THSTensor_new(dataArrayAddr, deleter, (IntPtr)shape, dimensions.Length, origType, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
+
+                    if (handle == IntPtr.Zero) {
+                        GC.Collect();
+                        GC.WaitForPendingFinalizers();
+                        handle = THSTensor_new(dataArrayAddr, deleter, (IntPtr)shape, dimensions.Length, origType, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
+                    }
+
+                    if (handle == IntPtr.Zero) { CheckForErrors(); }
+                    var tensor = new Tensor(handle);
+
+                    if (names != null && names.Length > 0) {
+                        tensor.rename_(names);
+                    }
+
+                    return tensor;
+                }
+            }
+        }
+
+        private static Tensor _tensor_generic<T>(Memory<T> rawArray, ReadOnlySpan<long> dimensions, sbyte origType, ScalarType? dtype, Device? device, bool requires_grad, bool clone = true, string[]? names = null)
+        {           
+            if (clone) 
+            { 
+                return _tensor_generic(rawArray.ToArray(), dimensions, origType, dtype, device, requires_grad, false, names); 
+            }
+
+            {
+                // Validate the sizes before handing over storage to native code...
+                var prod = 1L;
+                foreach (var sz in dimensions) prod *= sz;
+
+                if (origType == (sbyte)ScalarType.ComplexFloat32)
+                    prod *= 2;
+
+                if (prod > rawArray.Length)
+                    throw new ArgumentException($"mismatched total size creating a tensor from an array: {prod} vs. {rawArray.Length}");
+            }
+
+            device = InitializeDevice(device);
+
+            dtype = dtype.HasValue ? dtype : (ScalarType)origType;
+
+            unsafe {
+
+                var dataHandle = rawArray.Pin();
+                var dataArrayAddr = (IntPtr)dataHandle.Pointer;
+                
+                TorchSharp.PInvoke.GCHandleDeleter deleter = null!;
+                deleter = new TorchSharp.PInvoke.GCHandleDeleter((IntPtr ptr) => {
+                    dataHandle.Dispose();
+                    deleters.TryRemove(deleter, out deleter!);
+                });
+                deleters.TryAdd(deleter, deleter); // keep the delegate alive
+
+                void *ptr = null;
+                IntPtr iPtr = (IntPtr)ptr;
+                
                 fixed (long* shape = dimensions) {
                     var handle = THSTensor_new(dataArrayAddr, deleter, (IntPtr)shape, dimensions.Length, origType, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
 

src/TorchSharp/Tensor/Factories/tensor_Complex.cs

@@ -271,5 +271,14 @@ public static Tensor tensor(System.Numerics.Complex[,,,] rawArray, ScalarType? d
         {
             return _tensor_generic(rawArray, stackalloc long[] { rawArray.GetLongLength(0), rawArray.GetLongLength(1), rawArray.GetLongLength(2), rawArray.GetLongLength(3) }, (sbyte)ScalarType.ComplexFloat64, dtype, device, requires_grad, names: names);
         }
+
+        /// <summary>
+        /// Create a tensor from an array of values, shaping it based on the shape passed in.
+        /// </summary>
+        [Pure]
+        public static Tensor tensor(Memory<System.Numerics.Complex> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
+        {
+            return _tensor_generic(rawArray, dimensions, (sbyte)ScalarType.ComplexFloat64, dtype, device, requires_grad, names: names);
+        }
     }
 }

src/TorchSharp/Tensor/Factories/tensor_Half.cs

@@ -113,6 +113,15 @@ public static Tensor tensor(Half[,,,] rawArray, ScalarType? dtype = null, Device
         {
             return _tensor_generic(rawArray, stackalloc long[] { rawArray.GetLongLength(0), rawArray.GetLongLength(1), rawArray.GetLongLength(2), rawArray.GetLongLength(3) }, (sbyte)ScalarType.Float16, dtype, device, requires_grad, names: names);
         }
+
+        /// <summary>
+        /// Create a tensor from an array of values, shaping it based on the shape passed in.
+        /// </summary>
+        [Pure]
+        public static Tensor tensor(Memory<Half> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
+        {
+            return _tensor_generic(rawArray, dimensions, (sbyte)ScalarType.Float16, dtype, device, requires_grad, names: names);
+        }
 #endif
     }
 }

src/TorchSharp/Tensor/Factories/tensor_byte.cs

@@ -125,6 +125,15 @@ public static Tensor tensor(byte[,,,] rawArray, ScalarType? dtype = null, Device
             return _tensor_generic(rawArray, stackalloc long[] { rawArray.GetLongLength(0), rawArray.GetLongLength(1), rawArray.GetLongLength(2), rawArray.GetLongLength(3) }, (sbyte)ScalarType.Byte, dtype, device, requires_grad, names: names);
         }
 
+        /// <summary>
+        /// Create a tensor from an array of values, shaping it based on the shape passed in.
+        /// </summary>
+        [Pure]
+        public static Tensor tensor(Memory<byte> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
+        {
+            return _tensor_generic(rawArray, dimensions, (sbyte)ScalarType.Byte, dtype, device, requires_grad, names: names);
+        }
+
         /// <summary>
         /// Cast a tensor to a byte tensor.
         /// </summary>

src/TorchSharp/Tensor/Factories/tensor_double.cs

@@ -150,6 +150,15 @@ public static Tensor tensor(double[,,,] rawArray, ScalarType? dtype = null, Devi
             return _tensor_generic(rawArray, stackalloc long[] { rawArray.GetLongLength(0), rawArray.GetLongLength(1), rawArray.GetLongLength(2), rawArray.GetLongLength(3) }, (sbyte)ScalarType.Float64, dtype, device, requires_grad, names: names);
         }
 
+        /// <summary>
+        /// Create a tensor from an array of values, shaping it based on the shape passed in.
+        /// </summary>
+        [Pure]
+        public static Tensor tensor(Memory<double> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
+        {
+            return _tensor_generic(rawArray, dimensions, (sbyte)ScalarType.Float64, dtype, device, requires_grad, names: names);
+        }
+
         /// <summary>
         /// Cast a tensor to a 64-bit floating point tensor.
         /// </summary>

src/TorchSharp/Tensor/Factories/tensor_float.cs

@@ -159,6 +159,15 @@ public static Tensor tensor(float[,,,] rawArray, ScalarType? dtype = null, Devic
             return _tensor_generic(rawArray, stackalloc long[] { rawArray.GetLongLength(0), rawArray.GetLongLength(1), rawArray.GetLongLength(2), rawArray.GetLongLength(3) }, (sbyte)ScalarType.Float32, dtype, device, requires_grad, names: names);
         }
 
+        /// <summary>
+        /// Create a tensor from an array of values, shaping it based on the shape passed in.
+        /// </summary>
+        [Pure]
+        public static Tensor tensor(Memory<float> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
+        {
+            return _tensor_generic(rawArray, dimensions, (sbyte)ScalarType.Float32, dtype, device, requires_grad, names: names);
+        }
+
         /// <summary>
         /// Cast a tensor to a 32-bit floating point tensor.
         /// </summary>

src/TorchSharp/Tensor/Factories/tensor_int.cs

@@ -125,6 +125,15 @@ public static Tensor tensor(int[,,,] rawArray, ScalarType? dtype = null, Device?
             return _tensor_generic(rawArray, stackalloc long[] { rawArray.GetLongLength(0), rawArray.GetLongLength(1), rawArray.GetLongLength(2), rawArray.GetLongLength(3) }, (sbyte)ScalarType.Int32, dtype, device, requires_grad, names: names);
         }
 
+        /// <summary>
+        /// Create a tensor from an array of values, shaping it based on the shape passed in.
+        /// </summary>
+        [Pure]
+        public static Tensor tensor(Memory<int> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
+        {
+            return _tensor_generic(rawArray, dimensions, (sbyte)ScalarType.Int32, dtype, device, requires_grad, names: names);
+        }
+
         /// <summary>
         /// Cast a tensor to a 32-bit integer tensor.
         /// </summary>

src/TorchSharp/Tensor/Factories/tensor_long.cs

@@ -134,6 +134,15 @@ public static Tensor tensor(long[,,,] rawArray, ScalarType? dtype = null, Device
             return _tensor_i64(rawArray, stackalloc long[] { rawArray.GetLongLength(0), rawArray.GetLongLength(1), rawArray.GetLongLength(2), rawArray.GetLongLength(3) }, dtype, device, requires_grad, names: names);
         }
 
+        /// <summary>
+        /// Create a tensor from an array of values, shaping it based on the shape passed in.
+        /// </summary>
+        [Pure]
+        public static Tensor tensor(Memory<long> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
+        {
+            return _tensor_generic(rawArray, dimensions, (sbyte)ScalarType.Int64, dtype, device, requires_grad, names: names);
+        }
+
         /// <summary>
         /// Cast a tensor to a 64-bit integer tensor.
         /// </summary>

src/TorchSharp/Tensor/Factories/tensor_sbyte.cs

@@ -124,5 +124,14 @@ public static Tensor tensor(sbyte[,,,] rawArray, ScalarType? dtype = null, Devic
         {
             return _tensor_generic(rawArray, stackalloc long[] { rawArray.GetLongLength(0), rawArray.GetLongLength(1), rawArray.GetLongLength(2), rawArray.GetLongLength(3) }, (sbyte)ScalarType.Int8, dtype, device, requires_grad, names: names);
         }
+
+        /// <summary>
+        /// Create a tensor from an array of values, shaping it based on the shape passed in.
+        /// </summary>
+        [Pure]
+        public static Tensor tensor(Memory<sbyte> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
+        {
+            return _tensor_generic(rawArray, dimensions, (sbyte)ScalarType.Int8, dtype, device, requires_grad, names: names);
+        }
     }
 }