Removing the '{Float|Int|Complex|Bool}Tensor' static tensor factory classes.

All factory methods are in 'torch' now.

Author: Niklas Gustafsson

CONTRIBUTING.md

@@ -25,6 +25,7 @@ If you send us a PR, whether for documentation, examples, or library code, we re
 * **DO** refer to any relevant issues, and include [keywords](https://help.github.com/articles/closing-issues-via-commit-messages/) that automatically close issues when the PR is merged.
 * **DO** tag any users that should know about and/or review the change.
 * **DO** ensure each commit successfully builds.  The entire PR must pass all tests in the Continuous Integration (CI) system before it'll be merged.
+* **DO** add a brief description to the RELEASENOTES.md file at the top under the heading of the upcoming release.
 * **DO** address PR feedback in an additional commit(s) rather than amending the existing commits, and only rebase/squash them when necessary.  This makes it easier for reviewers to track changes.
 * **DO** assume that ["Squash and Merge"](https://github.com/blog/2141-squash-your-commits) will be used to merge your commit unless you request otherwise in the PR.
 * **DO NOT** fix merge conflicts using a merge commit. Prefer `git rebase`.

DEVGUIDE.md

@@ -70,23 +70,26 @@ To change the TorchSharp package version update this [file](https://github.com/d
 The TorchSharp package is pushed to nuget.org via Azure DevOps CI release pipeline.  Assuming you're not building or updating the LibTorch packages
 (`BuildLibTorchPackages` is `false` in [azure-pipelines.yml](azure-pipelines.yml)) this is pretty simple once you have the permissions:
 
-1. Integrate code to main and wait for CI to process
-2. Go to [releases](https://donsyme.visualstudio.com/TorchSharp/_release) and choose "Create Release" (top right)
-3. Under "Artifacts-->Version" choose the pipeline build corresponding to the thing you want to release.  It should be a successful build on main
-4. Press "Create"
+1. Update the version number in [./build/BranchInfo.props](./build/BranchInfo.props) and in the [Release Notes](./RELEASENOTES.md) file and then submit a PR. 
 
-The package version is currently taken from the CI build version.
+   Updating the major or minor version number should only be done after a discussion with repo admins. The patch number should be incremented by one each release and set to zero after a change to the major or minor version.
+2. Integrate code to main and wait for CI to process
+3. Go to [releases](https://donsyme.visualstudio.com/TorchSharp/_release) and choose "Create Release" (top right)
+4. Under "Artifacts-->Version" choose the pipeline build corresponding to the thing you want to release.  It should be a successful build on main
+5. Press "Create"
+
+6. Once the package has been successfully pushed and is available in the NuGet gallery, create a GitHub tag in the 'main' branch with the version  as the name of the tag.
 
 # The libtorch packages
 
 The libtorch packages are huge (~3GB compressed combined for CUDA Windows) and cause a
-lot of problems to make and deliver due to nuget package size restrictions.
+lot of problems to make and deliver due to NuGet package size restrictions.
 
 These problems include:
 
 1. A massive 2GB binary in the linux CUDA package and multiple 1.0GB binaries in Windows CUDA package
 
-2. Size limitations of about ~500MB on nuget packages on the Azure DevOps CI system and about ~250MB on `nuget.org`
+2. Size limitations of about ~500MB on NuGet packages on the Azure DevOps CI system and about ~250MB on `nuget.org`
 
 4. Regular download/upload failures on these systems due to network interruptions for packages of this size
 

src/RELEASENOTES.md RELEASENOTES.mdsrc/RELEASENOTES.md renamed to RELEASENOTES.md

@@ -11,6 +11,10 @@ __Fixed Bugs:__
 Fixed incorrectly implemented Module APIs related to parameter / module registration.
 #353 Missing torch.minimum (with an alternative raising exception)
 
+__API Changes:__
+
+Removed the type-named tensor factories, such as 'Int32Tensor.rand(),' etc.
+
 ### NuGet Version 0.92.52220
 
 This was the first release since moving TorchSharp to the .NET Foundation organization. Most of the new functionality is related to continuing the API changes that were started in the previous release, and fixing some bugs.

src/Examples/Program.cs

@@ -11,11 +11,11 @@ public static class Program
     {
         public static void Main(string[] args)
         {
-            //MNIST.Main(args);
-            //AdversarialExampleGeneration.Main(args);
+            MNIST.Main(args);
+            AdversarialExampleGeneration.Main(args);
             CIFAR10.Main(args);
-            //SequenceToSequence.Main(args);
-            //TextClassification.Main(args);
+            SequenceToSequence.Main(args);
+            TextClassification.Main(args);
             //ImageTransforms.Main(args);
         }
     }

src/FSharp.Examples/SequenceToSequence.fs

@@ -52,11 +52,11 @@ type PositionalEncoding(dmodel, maxLen) as this =
     inherit Module("PositionalEncoding")
 
     let dropout = Dropout(dropout)
-    let mutable pe = torch.Float32Tensor.zeros([| maxLen; dmodel|])
+    let mutable pe = torch.zeros([| maxLen; dmodel|])
 
     do
-        let position = torch.Float32Tensor.arange(0L.ToScalar(), maxLen.ToScalar(), 1L.ToScalar()).unsqueeze(1L)
-        let divTerm = (torch.Float32Tensor.arange(0L.ToScalar(), dmodel.ToScalar(), 2L.ToScalar()) * (-Math.Log(10000.0) / (float dmodel)).ToScalar()).exp()
+        let position = torch.arange(0L.ToScalar(), maxLen.ToScalar(), 1L.ToScalar()).unsqueeze(1L)
+        let divTerm = (torch.arange(0L.ToScalar(), dmodel.ToScalar(), 2L.ToScalar()) * (-Math.Log(10000.0) / (float dmodel)).ToScalar()).exp()
 
         let NULL = System.Nullable<int64>()
 
@@ -105,9 +105,9 @@ type TransformerModel(ntokens, device:torch.Device) as this =
         decoder.forward(enc)
 
     member _.GenerateSquareSubsequentMask(size:int64) =
-        use mask = torch.Float32Tensor.ones([|size;size|]).eq(torch.Float32Tensor.from(1.0f)).triu().transpose(0L,1L)
-        use maskIsZero = mask.eq(torch.Float32Tensor.from(0.0f))
-        use maskIsOne = mask.eq(torch.Float32Tensor.from(1.0f))
+        use mask = torch.ones([|size;size|]).eq(torch.tensor(1.0f)).triu().transpose(0L,1L)
+        use maskIsZero = mask.eq(torch.tensor(0.0f))
+        use maskIsOne = mask.eq(torch.tensor(1.0f))
         mask.to_type(torch.float32)
             .masked_fill(maskIsZero, Single.NegativeInfinity.ToScalar())
             .masked_fill(maskIsOne, 0.0f.ToScalar()).``to``(device)
@@ -117,7 +117,7 @@ let process_input (iter:string seq) (tokenizer:string->string seq) (vocab:TorchT
         [|
             for item in iter do
                 let itemData = [| for token in tokenizer(item) do (int64 vocab.[token]) |]
-                let t = torch.Int64Tensor.from(itemData)
+                let t = torch.tensor(itemData)
                 if t.NumberOfElements > 0L then
                     t
         |], 0L)

src/TorchSharp/NN/Losses.cs

@@ -421,7 +421,7 @@ public static GaussianNLLLoss gaussian_nll_loss(bool full = false, float eps = 1
 
                         if ((variance < 0).any().DataItem<bool>()) throw new ArgumentException("variance has negative entry/entries");
 
-                        variance = variance.clone().maximum(Float32Tensor.from(eps));
+                        variance = variance.clone().maximum(torch.tensor(eps));
 
                         var loss = 0.5 * (variance.log() + (input - target).square() / variance).view(input.shape[0], -1).sum(dimensions: new long[] { 1 });
 

src/TorchSharp/Tensor/Tensor.Factories.cs

@@ -35,8 +35,18 @@ public static partial class torch
 
         /// <summary>
         /// Creates 1-D tensor of size [(stop - start) / step] with values from interval [start, stop) and
-		/// common difference step, starting from start
-        /// </summary>
+        /// common difference step, starting from start
+        /// </summary>
+        /// <param name="start">The starting value for the set of points.</param>
+        /// <param name="stop">The ending value for the set of points</param>
+        /// <param name="step">The gap between each pair of adjacent points.</param>
+        /// <param name="dtype">the desired data type of returned tensor.
+        /// Default: if null, uses a global default (see torch.set_default_tensor_type()).
+        /// If dtype is not given, infer the data type from the other input arguments.
+        /// If any of start, end, or stop are floating-point, the dtype is inferred to be the default dtype, see get_default_dtype().
+        /// Otherwise, the dtype is inferred to be torch.int64.</param>
+        /// <param name="device"></param>
+        /// <param name="requiresGrad"> If autograd should record operations on the returned tensor. Default: false.</param>
         static public Tensor arange(Scalar start, Scalar stop, Scalar step, torch.ScalarType? dtype = null, torch.Device device = null, bool requiresGrad = false)
         {
             device = torch.InitializeDevice(device);
@@ -51,6 +61,13 @@ static public Tensor arange(Scalar start, Scalar stop, Scalar step, torch.Scalar
                 }
             }
 
+            if (dtype == ScalarType.ComplexFloat32) {
+                return ComplexFloat32Tensor.arange(start, stop, step, device, requiresGrad);
+            }
+            else if (dtype == ScalarType.ComplexFloat64) {
+                return ComplexFloat64Tensor.arange(start, stop, step, device, requiresGrad);
+            }
+
             var handle = THSTensor_arange(start.Handle, stop.Handle, step.Handle, (sbyte)dtype, (int)device.type, device.index, requiresGrad);
             if (handle == IntPtr.Zero) {
                 GC.Collect();
@@ -512,7 +529,6 @@ static public Tensor randint(long max, long[] size, torch.ScalarType? dtype = nu
             }
 
             if (dtype == ScalarType.ComplexFloat32) {
-
                 return randint_c32(max, size, device, requiresGrad);
             }
             else if (dtype == ScalarType.ComplexFloat64) {
@@ -848,6 +864,23 @@ public static Tensor tensor(double scalar, torch.ScalarType? dtype = null, torch
             return tensor;
         }
 
+        /// <summary>
+        /// Create a scalar tensor from a single value
+        /// </summary>
+        public static Tensor tensor(float real, float imaginary, torch.ScalarType? dtype = null, torch.Device device = null, bool requiresGrad = false)
+        {
+            device = torch.InitializeDevice(device);
+            var handle = THSTensor_newComplexFloat32Scalar(real, imaginary, (int)device.type, device.index, requiresGrad);
+            if (handle == IntPtr.Zero) { torch.CheckForErrors(); }
+            var tensor = new Tensor(handle);
+            if (device is not null) {
+                tensor = dtype.HasValue ? tensor.to(dtype.Value, device) : tensor.to(device);
+            } else if (dtype.HasValue) {
+                tensor = tensor.to_type(dtype.Value);
+            }
+            return tensor;
+        }
+
         /// <summary>
         /// Create a scalar tensor from a single value
         /// </summary>
@@ -865,6 +898,40 @@ public static Tensor tensor((float Real, float Imaginary) scalar, torch.ScalarTy
             return tensor;
         }
 
+        /// <summary>
+        /// Create a scalar tensor from a single value
+        /// </summary>
+        public static Tensor tensor((double Real, double Imaginary) scalar, torch.ScalarType? dtype = null, torch.Device device = null, bool requiresGrad = false)
+        {
+            device = torch.InitializeDevice(device);
+            var handle = THSTensor_newComplexFloat64Scalar(scalar.Real, scalar.Imaginary, (int)device.type, device.index, requiresGrad);
+            if (handle == IntPtr.Zero) { torch.CheckForErrors(); }
+            var tensor = new Tensor(handle);
+            if (device is not null) {
+                tensor = dtype.HasValue ? tensor.to(dtype.Value, device) : tensor.to(device);
+            } else if (dtype.HasValue) {
+                tensor = tensor.to_type(dtype.Value);
+            }
+            return tensor;
+        }
+
+        /// <summary>
+        /// Create a scalar tensor from a single value
+        /// </summary>
+        public static Tensor tensor(double real, double imaginary, torch.ScalarType? dtype = null, torch.Device device = null, bool requiresGrad = false)
+        {
+            device = torch.InitializeDevice(device);
+            var handle = THSTensor_newComplexFloat64Scalar(real, imaginary, (int)device.type, device.index, requiresGrad);
+            if (handle == IntPtr.Zero) { torch.CheckForErrors(); }
+            var tensor = new Tensor(handle);
+            if (device is not null) {
+                tensor = dtype.HasValue ? tensor.to(dtype.Value, device) : tensor.to(device);
+            } else if (dtype.HasValue) {
+                tensor = tensor.to_type(dtype.Value);
+            }
+            return tensor;
+        }
+
         /// <summary>
         /// Create a scalar tensor from a single value
         /// </summary>
@@ -1520,7 +1587,11 @@ public static Tensor tensor(IList<double> rawArray, long dim0, long dim1, long d
         public static Tensor tensor(IList<(float Real, float Imaginary)> rawArray, long[] dimensions, torch.ScalarType? dtype = null, torch.Device device = null, bool requiresGrad = false)
         {
             torch.InitializeDeviceType(DeviceType.CPU);
-            var dataArray = rawArray.ToArray();
+            var dataArray = new float[rawArray.Count * 2];
+            for (var i = 0; i < rawArray.Count; i++) {
+                dataArray[i * 2] = rawArray[i].Real;
+                dataArray[i * 2 + 1] = rawArray[i].Imaginary;
+            }
             unsafe {
                 var dataHandle = GCHandle.Alloc(dataArray, GCHandleType.Pinned);
                 var dataArrayAddr = dataHandle.AddrOfPinnedObject();
@@ -1539,13 +1610,7 @@ public static Tensor tensor(IList<(float Real, float Imaginary)> rawArray, long[
                     handle = THSTensor_new(dataArrayAddr, deleter, dimensions, dimensions.Length, (sbyte)ScalarType.ComplexFloat32, requiresGrad);
                 }
                 if (handle == IntPtr.Zero) { torch.CheckForErrors(); }
-                var tensor = new Tensor(handle);
-                if (device is not null) {
-                    tensor = dtype.HasValue ? tensor.to(dtype.Value, device) : tensor.to(device);
-                } else if (dtype.HasValue) {
-                    tensor = tensor.to_type(dtype.Value);
-                }
-                return tensor;
+                return new Tensor(handle);
             }
         }
 
@@ -1599,7 +1664,11 @@ public static Tensor tensor(IList<(float Real, float Imaginary)> rawArray, long
         public static Tensor tensor(IList<System.Numerics.Complex> rawArray, long[] dimensions, torch.ScalarType? dtype = null, torch.Device device = null, bool requiresGrad = false)
         {
             torch.InitializeDeviceType(DeviceType.CPU);
-            var dataArray = rawArray.ToArray();
+            var dataArray = new double[rawArray.Count * 2];
+            for (var i = 0; i < rawArray.Count; i++) {
+                dataArray[i * 2] = rawArray[i].Real;
+                dataArray[i * 2 + 1] = rawArray[i].Imaginary;
+            }
             unsafe {
                 var dataHandle = GCHandle.Alloc(dataArray, GCHandleType.Pinned);
                 var dataArrayAddr = dataHandle.AddrOfPinnedObject();
@@ -1618,13 +1687,7 @@ public static Tensor tensor(IList<System.Numerics.Complex> rawArray, long[] dime
                     handle = THSTensor_new(dataArrayAddr, deleter, dimensions, dimensions.Length, (sbyte)ScalarType.ComplexFloat64, requiresGrad);
                 }
                 if (handle == IntPtr.Zero) { torch.CheckForErrors(); }
-                var tensor = new Tensor(handle);
-                if (device is not null) {
-                    tensor = dtype.HasValue ? tensor.to(dtype.Value, device) : tensor.to(device);
-                } else if (dtype.HasValue) {
-                    tensor = tensor.to_type(dtype.Value);
-                }
-                return tensor;
+                return new Tensor(handle);
             }
         }
 

src/TorchSharp/Tensor/Tensor.cs

@@ -1243,7 +1243,7 @@ public Tensor take_along_dim(Tensor indices)
             /// <param name="indices">The indices into input. Must have long dtype.</param>
             /// <returns></returns>
             /// <remarks>Functions that return indices along a dimension, like torch.argmax() and torch.argsort(), are designed to work with this function.</remarks>
-            public Tensor take_along_dim(IEnumerable<long> indices) => take_along_dim(Int64Tensor.from(indices.ToArray()));
+            public Tensor take_along_dim(IEnumerable<long> indices) => take_along_dim(torch.tensor(indices.ToArray()));
 
             /// <summary>
             /// Selects values from input at the 1-dimensional indices from indices along the given dim.
@@ -1267,7 +1267,7 @@ public Tensor take_along_dim(Tensor indices, long dimension)
             /// <param name="dim">Dimension to select along.</param>
             /// <returns></returns>
             /// <remarks>Functions that return indices along a dimension, like torch.argmax() and torch.argsort(), are designed to work with this function.</remarks>
-            public Tensor take_along_dim(IEnumerable<long> indices, long dim) => take_along_dim(Int64Tensor.from(indices.ToArray()), dim);
+            public Tensor take_along_dim(IEnumerable<long> indices, long dim) => take_along_dim(torch.tensor(indices.ToArray()), dim);
 
             [DllImport("LibTorchSharp")]
             static extern IntPtr THSTensor_reshape(IntPtr tensor, IntPtr shape, int length);