Fix issue #1400

Author: NiklasGustafsson

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,23 @@ 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);
+        }
     }
 }