Merge branch 'main' into unit

Author: NiklasGustafsson

RELEASENOTES.md

@@ -2,24 +2,28 @@
 
 Releases, starting with 9/2/2021, are listed with the most recent release at the top.
 
-
 # NuGet Version 0.104.0
 
 This is a big change in implementation, but not as big in API surface area. Many of the builtin modules, but not all, were re-implemented in managed code calling into native code via the functional APIs. This has several advantages:
 
-1. Align with the Pytorch implementations.
-2. More easily expose module attributes as properties as Pytorch does.
-3. In some cases, avoid native code altogether.
-4. The builtin modules can serve as "best practice" examples for custom module authors.
+1. Align with the Pytorch implementations.<br/>
+2. More easily expose module attributes as properties as Pytorch does.<br/>
+3. In some cases, avoid native code altogether.<br/>
+4. The builtin modules can serve as "best practice" examples for custom module authors.<br/>
 
 __Breaking Changes__:
 
 The names of several arguments have been changed to align better with Pytorch naming. This may break code that passes such arguments by name, but will be caught at compile time.
 
+The argument defaults for `torch.diagonal()` and `Tensor.diagonal()` arguments have been corrected.
+
 __Issues fixed__:
 
 #1397 Look into whether parameter creation from a tensor leads to incorrect dispose scope statistics. This bug was discovered during testing of the PR.<br/>
 #1210 Attribute omissions.<br/>
+#1210 Attribute omissions.<br/>
+#1400 There may be an error in torchvision.transforms.GaussianBlur<br/>
+#1402 diagonal() has incorrect default<br/>
 
 # NuGet Version 0.103.1
 

src/TorchSharp/LinearAlgebra.cs

@@ -136,8 +136,8 @@ public static (Tensor, Tensor) slogdet(Tensor input)
             /// </summary>
             /// <param name="input">The input tensor</param>
             /// <param name="offset">Which diagonal to consider. Default: 0 (main diagonal).</param>
-            /// <param name="dim1">First dimension with respect to which to take diagonal. Default: -1.</param>
-            /// <param name="dim2">Second dimension with respect to which to take diagonal. Default: -2.</param>
+            /// <param name="dim1">First dimension with respect to which to take diagonal. Default: -2.</param>
+            /// <param name="dim2">Second dimension with respect to which to take diagonal. Default: -1.</param>
             /// <remarks>
             /// Applying torch.diag_embed() to the output of this function with the same arguments yields a diagonal matrix with the diagonal entries of the input.
             /// However, torch.diag_embed() has different default dimensions, so those need to be explicitly specified.

src/TorchSharp/Tensor/Tensor.cs

@@ -3399,8 +3399,9 @@ public Tensor diagflat(long offset = 0)
             /// Applying torch.diag_embed() to the output of this function with the same arguments yields a diagonal matrix with the diagonal entries of the input.
             /// However, torch.diag_embed() has different default dimensions, so those need to be explicitly specified.
             /// </remarks>
-            public Tensor diagonal(long offset = 0, long dim1 = 0, long dim2 = 0)
+            public Tensor diagonal(long offset = 0L, long dim1 = 0L, long dim2 = 1L)
             {
+                if (dim1 == dim2) throw new ArgumentException($"Diagonal dimensions cannot be identical {dim1}, {dim2}");
                 var res = NativeMethods.THSTensor_diagonal(Handle, offset, dim1, dim2);
                 if (res == IntPtr.Zero) { CheckForErrors(); }
                 return new Tensor(res);

src/TorchSharp/Tensor/torch.OtherOperations.cs

@@ -314,7 +314,7 @@ public static Tensor diag_embed(Tensor input, long offset = 0L, long dim1 = -2L,
         /// Applying torch.diag_embed() to the output of this function with the same arguments yields a diagonal matrix with the diagonal entries of the input.
         /// However, torch.diag_embed() has different default dimensions, so those need to be explicitly specified.
         /// </remarks>
-        public static Tensor diagonal(Tensor input, long offset = 0, long dim1 = 0, long dim2 = 0) => input.diagonal(offset, dim1, dim2);
+        public static Tensor diagonal(Tensor input, long offset = 0L, long dim1 = 0L, long dim2 = 1L) => input.diagonal(offset, dim1, dim2);
 
         // https://pytorch.org/docs/stable/generated/torch.diff
         /// <summary>

src/TorchVision/Functional.cs

@@ -443,24 +443,25 @@ public static Tensor erase(Tensor img, int top, int left, int height, int width,
                 /// The image is expected to have […, H, W] shape, where … means an arbitrary number of leading dimensions.
                 /// </summary>
                 /// <returns></returns>
-                public static Tensor gaussian_blur(Tensor input, IList<long> kernelSize, IList<float> sigma)
+                public static Tensor gaussian_blur(Tensor input, IList<long> kernelSize, ReadOnlySpan<float> sigma)
                 {
                     var dtype = torch.is_integral(input.dtype) ? ScalarType.Float32 : input.dtype;
 
                     if (kernelSize.Count == 1) {
                         kernelSize = new long[] { kernelSize[0], kernelSize[0] };
                     }
 
-                    if (sigma == null) {
+                    if (sigma == null || sigma.Length == 0)
+                    {
                         sigma = new float[] {
-                        0.3f * ((kernelSize[0] - 1) * 0.5f - 1) + 0.8f,
-                        0.3f * ((kernelSize[1] - 1) * 0.5f - 1) + 0.8f,
-                    };
-                    } else if (sigma.Count == 1) {
+                            0.3f * ((kernelSize[0] - 1) * 0.5f - 1) + 0.8f,
+                            0.3f * ((kernelSize[1] - 1) * 0.5f - 1) + 0.8f,
+                        };
+                    } else if (sigma.Length == 1) {
                         sigma = new float[] {
-                        sigma[0],
-                        sigma[0],
-                    };
+                            sigma[0],
+                            sigma[0],
+                        };
                     }
                     using var t0 = GetGaussianKernel2d(kernelSize, sigma, dtype, input.device);
                     using var kernel = t0.expand(input.shape[input.shape.Length - 3], 1, t0.shape[0], t0.shape[1]);
@@ -755,7 +756,7 @@ public static Tensor resized_crop(Tensor input, int top, int left, int height, i
                             throw new ArgumentException("Crop dimensions exceed image size.", nameof(input));
                         break;
                     default: // Any number of batch dimensions
-                        if (top + height > input.shape[input.ndim-2] || left + width > input.shape[input.ndim-1]) 
+                        if (top + height > input.shape[input.ndim-2] || left + width > input.shape[input.ndim-1])
                             throw new ArgumentException("Crop dimensions exceed image size.", nameof(input));
                         break;
                     case 1:
@@ -891,7 +892,7 @@ private static Tensor GetGaussianKernel1d(long size, float sigma)
                     return pdf / sum;
                 }
 
-                private static Tensor GetGaussianKernel2d(IList<long> kernelSize, IList<float> sigma, ScalarType dtype, torch.Device device)
+                private static Tensor GetGaussianKernel2d(IList<long> kernelSize, ReadOnlySpan<float> sigma, ScalarType dtype, torch.Device device)
                 {
                     using var tX1 = GetGaussianKernel1d(kernelSize[0], sigma[0]);
                     using var tX2 = tX1.to(dtype, device);

src/TorchVision/GaussianBlur.cs

@@ -9,29 +9,44 @@ namespace TorchSharp
 {
     public static partial class torchvision
     {
-        internal class GaussianBlur : ITransform
+        internal class GaussianBlur : torch.nn.Module<Tensor,Tensor>, ITransform
         {
-            internal GaussianBlur(IList<long> kernelSize, float min, float max)
+            internal GaussianBlur(IList<long> kernelSize, float sigma): base(nameof(GaussianBlur))
             {
                 if (kernelSize == null || kernelSize.Count != 2 || kernelSize.Any(x => x <= 0)) {
                     throw new ArgumentException("Invalid kernel size argument.");
                 }
-                if (min < 0 || max < 0 || min >= max) {
-                    throw new ArgumentException("Invalid GaussianBlur arguments.");
+                if (sigma <= 0) {
+                    throw new ArgumentException("Invalid GaussianBlur arguments: sigma must be positive.");
                 }
-                this.sigma = (min == max) ?
-                    min :
-                    (float)(new Random().NextDouble() * (max - min) + min);
+                this.sigma = sigma;
                 this.kernelSize = kernelSize.ToArray();
             }
 
-            public Tensor call(Tensor input)
+            internal GaussianBlur(IList<long> kernelSize, float sigma_min, float sigma_max) : base(nameof(GaussianBlur))
             {
-                return transforms.functional.gaussian_blur(input, kernelSize, new float[] { sigma });
+                if (kernelSize == null || kernelSize.Count != 2 || kernelSize.Any(x => x <= 0)) {
+                    throw new ArgumentException("Invalid kernel size argument.");
+                }
+                if (sigma_min < 0 || sigma_max < 0 || sigma_min > sigma_max) {
+                    throw new ArgumentException("Invalid GaussianBlur arguments: min and max must be positive and min <= max");
+                }
+                // Leave 'this.sigma' null.
+                this.sigma_min = sigma_min;
+                this.sigma_max = sigma_max;
+                this.kernelSize = kernelSize.ToArray();
+            }
+
+            public override Tensor forward(Tensor input)
+            {
+                var s = sigma.HasValue ? sigma.Value : torch.empty(1).uniform_(sigma_min, sigma_max).item<float>();
+                return transforms.functional.gaussian_blur(input, kernelSize,  stackalloc[]{s, s});
             }
 
             protected long[] kernelSize;
-            protected float sigma;
+            protected float? sigma;
+            protected float sigma_min;
+            protected float sigma_max;
         }
 
         public static partial class transforms
@@ -44,7 +59,7 @@ public static partial class transforms
             /// <returns></returns>
             static public ITransform GaussianBlur(IList<long> kernelSize, float sigma)
             {
-                return new GaussianBlur(kernelSize, sigma, sigma);
+                return new GaussianBlur(kernelSize, sigma);
             }
 
             /// <summary>

test/TorchSharpTest/TestTorchTensorBugs.cs

@@ -1681,5 +1681,26 @@ public void ValidateLoadWithDeflateStream()
             }
 #endif
         }
+
+        [Fact]
+        public void Validate1400()
+        {
+            long kernel = 21;
+            float sigma = 11;
+            var trans = torchvision.transforms.GaussianBlur(kernel, sigma); //System.ArgumentException:“Invalid GaussianBlur arguments.”
+
+            var img = torch.rand(1,3,256,256);
+            var t = trans.call(img);
+        }
+
+        [Fact]
+        public void Validate1402()
+        {
+            var t = torch.arange(100).reshape(10,10);
+
+            var d = t.diagonal();
+
+            Assert.Equal(new long[]{0, 11, 22, 33, 44, 55, 66, 77, 88, 99}, d.data<long>().ToArray());
+        }
     }
 }