Adapted to some API Compat complaints.

NiklasGustafsson · NiklasGustafsson · commit 3e77e9f8d904 · 2024-11-11T13:39:48.000-08:00
diff --git a/src/TorchSharp/NN/Activation/GELU.cs b/src/TorchSharp/NN/Activation/GELU.cs
@@ -32,11 +32,19 @@ public static partial class torch
     {
         public static partial class nn
         {
+            /// <summary>
+            /// Gaussian Error Linear Units
+            /// </summary>
+            public static GELU GELU()
+            {
+                return new GELU(false);
+            }
+
             /// <summary>
             /// Gaussian Error Linear Units
             /// </summary>
             /// <param name="inplace">Do the operation in-place. Default: False</param>
-            public static GELU GELU(bool inplace = false)
+            public static GELU GELU(bool inplace)
             {
                 return new GELU(inplace);
             }
@@ -48,10 +56,20 @@ public static partial class functional
                 /// </summary>
                 /// <param name="x">The input tensor</param>
                 /// <param name="inplace">Do the operation in-place. Default: False</param>
-                public static Tensor gelu(Tensor x, bool inplace = false)
+                public static Tensor gelu(Tensor x, bool inplace)
                 {
                     return inplace ? x.gelu_().alias() : x.gelu();
                 }
+
+                /// <summary>
+                /// Gaussian Error Linear Units
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                /// <remarks>The defaulting of 'inplace' to 'false' is implemented as an overload to avoid a breaking change.</remarks>
+                public static Tensor gelu(Tensor x)
+                {
+                    return gelu(x,false);
+                }
             }
         }
     }
diff --git a/src/TorchSharp/NN/Activation/Hardshrink.cs b/src/TorchSharp/NN/Activation/Hardshrink.cs
@@ -57,6 +57,15 @@ public static Tensor hardshrink(Tensor x, double lambda = 0.5)
                     if (result == IntPtr.Zero) { torch.CheckForErrors(); }
                     return new Tensor(result);
                 }
+
+                /// <summary>
+                /// Hardshrink
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                /// <param name="lambda">The λ value for the Hardshrink formulation. Default: 0.5</param>
+                /// <remarks>Only here for backward comaptibility.</remarks>
+                [Obsolete("Not using the PyTorch naming convention.",false)]
+                public static Tensor Hardshrink(Tensor x, double lambda = 0.5) => hardshrink(x, lambda);
             }
         }
     }
diff --git a/src/TorchSharp/NN/Activation/Hardtanh.cs b/src/TorchSharp/NN/Activation/Hardtanh.cs
@@ -67,6 +67,17 @@ public static Tensor hardtanh(Tensor x, double min_val = -1.0, double max_val =
                 {
                     return inplace ? x.hardtanh_(min_val, max_val).alias() : x.hardtanh(min_val, max_val);
                 }
+
+                /// <summary>
+                /// Hardshrink
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                /// <param name="min_val">Minimum value of the linear region range.</param>
+                /// <param name="max_val">Maximum value of the linear region range.</param>
+                /// <param name="inplace">Do the operation in-place</param>
+                /// <remarks>Only here for backward comaptibility.</remarks>
+                [Obsolete("Not using the PyTorch naming convention.",false)]
+                public static Tensor Hardtanh(Tensor x, double min_val = -1.0, double max_val = 1.0, bool inplace = false) => hardtanh(x, min_val, max_val, inplace);
             }
         }
     }
diff --git a/src/TorchSharp/NN/Activation/Mish.cs b/src/TorchSharp/NN/Activation/Mish.cs
@@ -32,11 +32,19 @@ public static partial class torch
     {
         public static partial class nn
         {
+            /// <summary>
+            /// A Self Regularized Non-Monotonic Neural Activation Function.
+            /// </summary>
+            public static Mish Mish()
+            {
+                return new Mish(false);
+            }
+
             /// <summary>
             /// A Self Regularized Non-Monotonic Neural Activation Function.
             /// </summary>
             /// <param name="inplace">Do the operation in-place. Default: False</param>
-            public static Mish Mish(bool inplace = false)
+            public static Mish Mish(bool inplace)
             {
                 return new Mish(inplace);
             }
@@ -54,6 +62,13 @@ public static Tensor mish(Tensor x, bool inplace = false)
                     using var t2 = t1.tanh();
                     return inplace ? x.mul_(t2).alias() : x.mul(t2);
                 }
+
+                /// <summary>
+                /// A Self Regularized Non-Monotonic Neural Activation Function.
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                [Obsolete("Not using the PyTorch naming convention.",false)]
+                public static Tensor Mish(Tensor x) => mish(x, false);
             }
         }
     }
diff --git a/src/TorchSharp/NN/Activation/SiLU.cs b/src/TorchSharp/NN/Activation/SiLU.cs
@@ -39,7 +39,15 @@ public static partial class nn
             /// <summary>
             /// Sigmoid-Weighted Linear Unit
             /// </summary>
-            public static SiLU SiLU(bool inplace = false)
+            public static SiLU SiLU()
+            {
+                return new SiLU(false);
+            }
+
+            /// <summary>
+            /// Sigmoid-Weighted Linear Unit
+            /// </summary>
+            public static SiLU SiLU(bool inplace)
             {
                 return new SiLU(inplace);
             }
diff --git a/src/TorchSharp/NN/Activation/Sigmoid.cs b/src/TorchSharp/NN/Activation/Sigmoid.cs
@@ -31,6 +31,15 @@ public static partial class torch
     {
         public static partial class nn
         {
+            /// <summary>
+            /// Sigmoid activation
+            /// </summary>
+            /// <returns></returns>
+            public static Sigmoid Sigmoid()
+            {
+                return new Sigmoid(false);
+            }
+
             /// <summary>
             /// Sigmoid activation
             /// </summary>
@@ -49,10 +58,20 @@ public static partial class functional
                 /// <param name="x">The input tensor</param>
                 /// <param name="inplace">Do the operation in-place. Default: False</param>
                 /// <returns></returns>
-                public static Tensor sigmoid(Tensor x, bool inplace = false)
+                public static Tensor sigmoid(Tensor x, bool inplace)
                 {
                     return inplace ? x.sigmoid_().alias() : x.sigmoid();
                 }
+
+                /// <summary>
+                /// Gaussian Error Linear Units
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                /// <remarks>The defaulting of 'inplace' to 'false' is implemented as an overload to avoid a breaking change.</remarks>
+                public static Tensor sigmoid(Tensor x)
+                {
+                    return sigmoid(x,false);
+                }
             }
         }
     }
diff --git a/src/TorchSharp/NN/Activation/Softplus.cs b/src/TorchSharp/NN/Activation/Softplus.cs
@@ -14,7 +14,7 @@ namespace Modules
         /// </summary>
         public sealed class Softplus : ParameterLessModule<Tensor, Tensor>
         {
-            internal Softplus(int beta = 1, int threshold = 20) : base(nameof(Softplus))
+            internal Softplus(double beta = 1, double threshold = 20) : base(nameof(Softplus))
             {
                 this.beta = beta;
                 this.threshold = threshold;
@@ -25,8 +25,8 @@ public override Tensor forward(Tensor tensor)
                 return torch.nn.functional.softplus(tensor, beta, threshold);
             }
 
-            public int beta {get; set;}
-            public int threshold {get; set;}
+            public double beta {get; set;}
+            public double threshold {get; set;}
         }
     }
 
@@ -40,7 +40,7 @@ public static partial class nn
             /// <param name="beta">The β value for the Softplus formulation.</param>
             /// <param name="threshold">Values above this revert to a linear function</param>
             /// <returns></returns>
-            public static Softplus Softplus(int beta = 1, int threshold = 20)
+            public static Softplus Softplus(double beta = 1, double threshold = 20)
             {
                 return new Softplus(beta, threshold);
             }
@@ -54,7 +54,7 @@ public static partial class functional
                 /// <param name="beta">The β value for the Softplus formulation.</param>
                 /// <param name="threshold">Values above this revert to a linear function</param>
                 /// <returns></returns>
-                public static Tensor softplus(Tensor x, int beta = 1, int threshold = 20)
+                public static Tensor softplus(Tensor x, double beta = 1, double threshold = 20)
                 {
                     return x.softplus(beta, threshold);
                 }
diff --git a/src/TorchSharp/NN/Activation/Softshrink.cs b/src/TorchSharp/NN/Activation/Softshrink.cs
@@ -57,6 +57,14 @@ public static Tensor softshrink(Tensor x, double lambda = 0.5)
                     if (result == IntPtr.Zero) { torch.CheckForErrors(); }
                     return new Tensor(result);
                 }
+
+                /// <summary>
+                /// Softshrink
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                /// <param name="lambda">The λ value for the Softshrink formulation. Default: 0.5</param>
+                [Obsolete("Not using the PyTorch naming convention.",false)]
+                public static Tensor Softshrink(Tensor x, double lambda = 0.5) => softshrink(x, lambda);
             }
         }
     }
diff --git a/src/TorchSharp/NN/Activation/Softsign.cs b/src/TorchSharp/NN/Activation/Softsign.cs
@@ -54,6 +54,13 @@ public static Tensor softsign(Tensor x, bool inplace = false)
                     using var y = 1 + abs;
                     return inplace ? x.div_(y).alias() : x.div(y);
                 }
+
+                /// <summary>
+                /// Softsign
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                [Obsolete("Not using the PyTorch naming convention.",false)]
+                public static Tensor Softsign(Tensor x) => softsign(x, false);
             }
         }
     }
diff --git a/src/TorchSharp/NN/Activation/Tanh.cs b/src/TorchSharp/NN/Activation/Tanh.cs
@@ -37,6 +37,15 @@ public static partial class torch
     {
         public static partial class nn
         {
+            /// <summary>
+            /// Tanh activation
+            /// </summary>
+            /// <returns></returns>
+            public static Tanh Tanh()
+            {
+                return new Tanh(false);
+            }
+
             /// <summary>
             /// Tanh activation
             /// </summary>
diff --git a/src/TorchSharp/NN/Activation/Tanhshrink.cs b/src/TorchSharp/NN/Activation/Tanhshrink.cs
@@ -32,6 +32,14 @@ public static partial class torch
     {
         public static partial class nn
         {
+            /// <summary>
+            /// Tanhshrink
+            /// </summary>
+            public static Tanhshrink Tanhshrink()
+            {
+                return new Tanhshrink(false);
+            }
+
             /// <summary>
             /// Tanhshrink
             /// </summary>
@@ -53,6 +61,13 @@ public static Tensor tanhshrink(Tensor x, bool inplace = false)
                     using var tanh_x = x.tanh();
                     return inplace ? x.sub_(tanh_x).alias() : x.sub(tanh_x);
                 }
+
+                /// <summary>
+                /// Tanhshrink
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                [Obsolete("Not using the PyTorch naming convention.",false)]
+                public static Tensor tanhshrink(Tensor x) => tanhshrink(x, false);
             }
         }
     }
diff --git a/src/TorchSharp/NN/Activation/Threshold.cs b/src/TorchSharp/NN/Activation/Threshold.cs
@@ -59,11 +59,19 @@ public static partial class functional
                 /// <param name="threshold">The value to threshold at</param>
                 /// <param name="value">The value to replace with</param>
                 /// <param name="inplace">Do the operation in-place</param>
-                /// <returns></returns>
                 public static Tensor threshold(Tensor x, double threshold, double value, bool inplace = false)
                 {
                     return inplace ? x.threshold_(threshold, value).alias() : x.threshold(threshold, value);
                 }
+
+                /// <summary>
+                /// Thresholds each element of the input Tensor.
+                /// </summary>
+                /// <param name="x">The input tensor</param>
+                /// <param name="threshold">The value to threshold at</param>
+                /// <param name="value">The value to replace with</param>
+                [Obsolete("Not using the PyTorch naming convention.",false)]
+                public static Tensor Threshold(Tensor x, double threshold, double value) => nn.functional.threshold(x, threshold, value, false);
             }
         }
     }
diff --git a/src/TorchSharp/NN/Convolution/Convolution.cs b/src/TorchSharp/NN/Convolution/Convolution.cs
@@ -187,6 +187,12 @@ protected internal override nn.Module _to(ScalarType dtype, bool non_blocking) {
                 return this;
             }
 
+            // Included to avoid API compat issues.
+            [Obsolete("Deprecated API", true)]
+            protected Convolution(IntPtr handle, IntPtr boxedHandle, long input_channels) : base(handle, boxedHandle) {
+                throw new NotImplementedException("Deprecated API.");
+            }
+
             [ComponentName(Name = BiasComponentName)]
             protected Parameter? _bias;
             [ComponentName(Name = WeightComponentName)]
@@ -198,6 +204,9 @@ protected internal override nn.Module _to(ScalarType dtype, bool non_blocking) {
             // reverse order than the dimension.
             protected long[] _reversed_padding_repeated_twice;
 
+            [Obsolete("Deprecated.", true)]
+            protected long input_channels;
+
             public long in_channels { get; }
             public long out_channels { get; }
             public bool transposed { get; }
diff --git a/src/TorchSharp/NN/FeatureDropout.cs b/src/TorchSharp/NN/FeatureDropout.cs
@@ -42,11 +42,23 @@ public static partial class nn
             /// </summary>
             /// <param name="p">Dropout probability of a channel to be zeroed. Default: 0.5</param>
             /// <param name="inplace">If set to true, will do this operation in-place. Default: false</param>
-            public static FeatureAlphaDropout FeatureAlphaDropout(double p = 0.5, bool inplace = false)
+            public static FeatureAlphaDropout FeatureAlphaDropout(double p, bool inplace)
             {
                 return new FeatureAlphaDropout(p, inplace);
             }
 
+            /// <summary>
+            /// Randomly masks out entire channels (a channel is a feature map, e.g. the j-th channel of the i-th sample in the batch input is a tensor input[i,j]) of the input tensor.
+            /// Instead of setting activations to zero, as in regular Dropout, the activations are set to the negative saturation value of the SELU activation function.
+            /// Each element will be masked independently on every forward call with probability p using samples from a Bernoulli distribution.The elements to be masked are
+            /// randomized on every forward call, and scaled and shifted to maintain zero mean and unit variance.
+            /// </summary>
+            /// <param name="p">Dropout probability of a channel to be zeroed. Default: 0.5</param>
+            public static FeatureAlphaDropout FeatureAlphaDropout(double p = 0.5)
+            {
+                return new FeatureAlphaDropout(p, false);
+            }
+
             public static partial class functional
             {
                 /// <summary>
diff --git a/src/TorchSharp/NN/Normalization/NormBase.cs b/src/TorchSharp/NN/Normalization/NormBase.cs
@@ -52,6 +52,9 @@ private void ResetRunningStats()
                 }
             }
 
+            // For backward compat.
+            public void reset_running_stats() => ResetRunningStats();
+
             public void reset_parameters() {
                 ResetRunningStats();
                 if (affine) {
diff --git a/src/TorchSharp/Tensor/Tensor.cs b/src/TorchSharp/Tensor/Tensor.cs
@@ -2724,7 +2724,7 @@ public Tensor softmax(long dim, ScalarType? dtype = null) =>
                 torch.special.softmax(this, dim, dtype);
 
 
-            public Tensor softplus(int beta = 1, int threshold = 20) =>
+            public Tensor softplus(double beta = 1, double threshold = 20) =>
                 softplus1(beta, threshold);
 
             private Tensor softplus1(Scalar beta, Scalar threshold)

Original file line number	Diff line number	Diff line change
`@@ -32,11 +32,19 @@ public static partial class torch`
`32`	`32`	`{`
`33`	`33`	`public static partial class nn`
`34`	`34`	`{`
	`35`	`+ /// <summary>`
	`36`	`+ /// Gaussian Error Linear Units`
	`37`	`+ /// </summary>`
	`38`	`+ public static GELU GELU()`
	`39`	`+ {`
	`40`	`+ return new GELU(false);`
	`41`	`+ }`
	`42`	`+`
`35`	`43`	`/// <summary>`
`36`	`44`	`/// Gaussian Error Linear Units`
`37`	`45`	`/// </summary>`
`38`	`46`	`/// <param name="inplace">Do the operation in-place. Default: False</param>`
`39`		`- public static GELU GELU(bool inplace = false)`
	`47`	`+ public static GELU GELU(bool inplace)`
`40`	`48`	`{`
`41`	`49`	`return new GELU(inplace);`
`42`	`50`	`}`
`@@ -48,10 +56,20 @@ public static partial class functional`
`48`	`56`	`/// </summary>`
`49`	`57`	`/// <param name="x">The input tensor</param>`
`50`	`58`	`/// <param name="inplace">Do the operation in-place. Default: False</param>`
`51`		`- public static Tensor gelu(Tensor x, bool inplace = false)`
	`59`	`+ public static Tensor gelu(Tensor x, bool inplace)`
`52`	`60`	`{`
`53`	`61`	`return inplace ? x.gelu_().alias() : x.gelu();`
`54`	`62`	`}`
	`63`	`+`
	`64`	`+ /// <summary>`
	`65`	`+ /// Gaussian Error Linear Units`
	`66`	`+ /// </summary>`
	`67`	`+ /// <param name="x">The input tensor</param>`
	`68`	`+ /// <remarks>The defaulting of 'inplace' to 'false' is implemented as an overload to avoid a breaking change.</remarks>`
	`69`	`+ public static Tensor gelu(Tensor x)`
	`70`	`+ {`
	`71`	`+ return gelu(x,false);`
	`72`	`+ }`
`55`	`73`	`}`
`56`	`74`	`}`
`57`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,6 +57,15 @@ public static Tensor hardshrink(Tensor x, double lambda = 0.5)`
`57`	`57`	`if (result == IntPtr.Zero) { torch.CheckForErrors(); }`
`58`	`58`	`return new Tensor(result);`
`59`	`59`	`}`
	`60`	`+`
	`61`	`+ /// <summary>`
	`62`	`+ /// Hardshrink`
	`63`	`+ /// </summary>`
	`64`	`+ /// <param name="x">The input tensor</param>`
	`65`	`+ /// <param name="lambda">The λ value for the Hardshrink formulation. Default: 0.5</param>`
	`66`	`+ /// <remarks>Only here for backward comaptibility.</remarks>`
	`67`	`+ [Obsolete("Not using the PyTorch naming convention.",false)]`
	`68`	`+ public static Tensor Hardshrink(Tensor x, double lambda = 0.5) => hardshrink(x, lambda);`
`60`	`69`	`}`
`61`	`70`	`}`
`62`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,17 @@ public static Tensor hardtanh(Tensor x, double min_val = -1.0, double max_val =`
`67`	`67`	`{`
`68`	`68`	`return inplace ? x.hardtanh_(min_val, max_val).alias() : x.hardtanh(min_val, max_val);`
`69`	`69`	`}`
	`70`	`+`
	`71`	`+ /// <summary>`
	`72`	`+ /// Hardshrink`
	`73`	`+ /// </summary>`
	`74`	`+ /// <param name="x">The input tensor</param>`
	`75`	`+ /// <param name="min_val">Minimum value of the linear region range.</param>`
	`76`	`+ /// <param name="max_val">Maximum value of the linear region range.</param>`
	`77`	`+ /// <param name="inplace">Do the operation in-place</param>`
	`78`	`+ /// <remarks>Only here for backward comaptibility.</remarks>`
	`79`	`+ [Obsolete("Not using the PyTorch naming convention.",false)]`
	`80`	`+ public static Tensor Hardtanh(Tensor x, double min_val = -1.0, double max_val = 1.0, bool inplace = false) => hardtanh(x, min_val, max_val, inplace);`
`70`	`81`	`}`
`71`	`82`	`}`
`72`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,15 @@ public static partial class torch`
`31`	`31`	`{`
`32`	`32`	`public static partial class nn`
`33`	`33`	`{`
	`34`	`+ /// <summary>`
	`35`	`+ /// Sigmoid activation`
	`36`	`+ /// </summary>`
	`37`	`+ /// <returns></returns>`
	`38`	`+ public static Sigmoid Sigmoid()`
	`39`	`+ {`
	`40`	`+ return new Sigmoid(false);`
	`41`	`+ }`
	`42`	`+`
`34`	`43`	`/// <summary>`
`35`	`44`	`/// Sigmoid activation`
`36`	`45`	`/// </summary>`
`@@ -49,10 +58,20 @@ public static partial class functional`
`49`	`58`	`/// <param name="x">The input tensor</param>`
`50`	`59`	`/// <param name="inplace">Do the operation in-place. Default: False</param>`
`51`	`60`	`/// <returns></returns>`
`52`		`- public static Tensor sigmoid(Tensor x, bool inplace = false)`
	`61`	`+ public static Tensor sigmoid(Tensor x, bool inplace)`
`53`	`62`	`{`
`54`	`63`	`return inplace ? x.sigmoid_().alias() : x.sigmoid();`
`55`	`64`	`}`
	`65`	`+`
	`66`	`+ /// <summary>`
	`67`	`+ /// Gaussian Error Linear Units`
	`68`	`+ /// </summary>`
	`69`	`+ /// <param name="x">The input tensor</param>`
	`70`	`+ /// <remarks>The defaulting of 'inplace' to 'false' is implemented as an overload to avoid a breaking change.</remarks>`
	`71`	`+ public static Tensor sigmoid(Tensor x)`
	`72`	`+ {`
	`73`	`+ return sigmoid(x,false);`
	`74`	`+ }`
`56`	`75`	`}`
`57`	`76`	`}`
`58`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ namespace Modules`
`14`	`14`	`/// </summary>`
`15`	`15`	`public sealed class Softplus : ParameterLessModule<Tensor, Tensor>`
`16`	`16`	`{`
`17`		`- internal Softplus(int beta = 1, int threshold = 20) : base(nameof(Softplus))`
	`17`	`+ internal Softplus(double beta = 1, double threshold = 20) : base(nameof(Softplus))`
`18`	`18`	`{`
`19`	`19`	`this.beta = beta;`
`20`	`20`	`this.threshold = threshold;`
`@@ -25,8 +25,8 @@ public override Tensor forward(Tensor tensor)`
`25`	`25`	`return torch.nn.functional.softplus(tensor, beta, threshold);`
`26`	`26`	`}`
`27`	`27`
`28`		`- public int beta {get; set;}`
`29`		`- public int threshold {get; set;}`
	`28`	`+ public double beta {get; set;}`
	`29`	`+ public double threshold {get; set;}`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`@@ -40,7 +40,7 @@ public static partial class nn`
`40`	`40`	`/// <param name="beta">The β value for the Softplus formulation.</param>`
`41`	`41`	`/// <param name="threshold">Values above this revert to a linear function</param>`
`42`	`42`	`/// <returns></returns>`
`43`		`- public static Softplus Softplus(int beta = 1, int threshold = 20)`
	`43`	`+ public static Softplus Softplus(double beta = 1, double threshold = 20)`
`44`	`44`	`{`
`45`	`45`	`return new Softplus(beta, threshold);`
`46`	`46`	`}`
`@@ -54,7 +54,7 @@ public static partial class functional`
`54`	`54`	`/// <param name="beta">The β value for the Softplus formulation.</param>`
`55`	`55`	`/// <param name="threshold">Values above this revert to a linear function</param>`
`56`	`56`	`/// <returns></returns>`
`57`		`- public static Tensor softplus(Tensor x, int beta = 1, int threshold = 20)`
	`57`	`+ public static Tensor softplus(Tensor x, double beta = 1, double threshold = 20)`
`58`	`58`	`{`
`59`	`59`	`return x.softplus(beta, threshold);`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,6 +57,14 @@ public static Tensor softshrink(Tensor x, double lambda = 0.5)`
`57`	`57`	`if (result == IntPtr.Zero) { torch.CheckForErrors(); }`
`58`	`58`	`return new Tensor(result);`
`59`	`59`	`}`
	`60`	`+`
	`61`	`+ /// <summary>`
	`62`	`+ /// Softshrink`
	`63`	`+ /// </summary>`
	`64`	`+ /// <param name="x">The input tensor</param>`
	`65`	`+ /// <param name="lambda">The λ value for the Softshrink formulation. Default: 0.5</param>`
	`66`	`+ [Obsolete("Not using the PyTorch naming convention.",false)]`
	`67`	`+ public static Tensor Softshrink(Tensor x, double lambda = 0.5) => softshrink(x, lambda);`
`60`	`68`	`}`
`61`	`69`	`}`
`62`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,13 @@ public static Tensor softsign(Tensor x, bool inplace = false)`
`54`	`54`	`using var y = 1 + abs;`
`55`	`55`	`return inplace ? x.div_(y).alias() : x.div(y);`
`56`	`56`	`}`
	`57`	`+`
	`58`	`+ /// <summary>`
	`59`	`+ /// Softsign`
	`60`	`+ /// </summary>`
	`61`	`+ /// <param name="x">The input tensor</param>`
	`62`	`+ [Obsolete("Not using the PyTorch naming convention.",false)]`
	`63`	`+ public static Tensor Softsign(Tensor x) => softsign(x, false);`
`57`	`64`	`}`
`58`	`65`	`}`
`59`	`66`	`}`