Merge pull request #1401 from NiklasGustafsson/bugs

Fix issues #1400 and #1402

Author: NiklasGustafsson

RELEASENOTES.md

@@ -2,6 +2,17 @@
 
 Releases, starting with 9/2/2021, are listed with the most recent release at the top.
 
+# NuGet Version 0.104.0
+
+__Breaking Changes__:
+
+The argument defaults for `torch.diagonal()` and `Tensor.diagonal()` arguments have been changed.
+
+__Bug Fixes__:
+
+#1400 There may be an error in torchvision.transforms.GaussianBlur
+#1402 diagonal() has incorrect default
+
 # NuGet Version 0.103.1
 
 __Breaking Changes__:

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

@@ -3329,8 +3329,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

@@ -313,7 +313,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

@@ -1612,7 +1612,7 @@ public void Validate_1191_3()
             Assert.NotNull(module.p.grad);
             Assert.NotNull(module.ln.weight!.grad);
             Assert.NotNull(module.ln.bias!.grad);
-            
+
         }
 
         [Fact]
@@ -1645,7 +1645,7 @@ public void Validate_1249()
             var y1 = torch.nn.functional.avg_pool1d(x, 2);
             Console.WriteLine(y1.metastr());
             Assert.Equal(64, y1.size(-1));
-            
+
             var y2 = torch.nn.AvgPool1d(2).call(x);
             Console.WriteLine(y2.metastr());
             Assert.Equal(64, y1.size(-1));
@@ -1674,12 +1674,33 @@ public void ValidateLoadWithDeflateStream()
                     seq.save(stream);
             }
 
-            // This test will succeed if the following code doesn't crash. 
+            // This test will succeed if the following code doesn't crash.
             ms.Position = 0;
             using (var archive = new ZipArchive(ms)) {
                 seq.load(archive.GetEntry("seq")!.Open());
             }
 #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());
+        }
     }
 }