Merge pull request #1 from NiklasGustafsson/unit

from NiklasGustafsson/Unit to yueyinqiu2/munit

Author: yueyinqiu

RELEASENOTES.md

@@ -2,11 +2,36 @@
 
 Releases, starting with 9/2/2021, are listed with the most recent release at the top.
 
+# NuGet Version 0.102.5
+
+__Breaking Changes__:
+
+__API Changes__:
+
+__Bug Fixes__:
+
+
+# NuGet Version 0.102.4
+
+__Breaking Changes__:
+
+Correct `torch.finfo`. (`torch.set_default_dtype`, `Categorical.entropy`, `_CorrCholesky.check`, `Distribution.ClampProbs`, `FisherSnedecor.rsample`, `Gamma.rsample`, `Geometric.rsample`, `distributions.Gumbel`, `Laplace.rsample`, `SigmoidTransform._call` and `SigmoidTransform._inverse` are influenced.)<br/>
+
+__API Changes__:
+
+#1284 make `torch.unique` and `torch.unique_consecutive` public.<br/>
+
 # NuGet Version 0.102.3
 
+__Breaking Changes__:
+
+The 'paddingMode' parameter of convolution has been changed to 'padding_mode', and the 'outputPadding' is now 'output_padding'.
+
 __API Changes__:
 
 #1243 `fuse_conv_bn_weights` and `fuse_linear_bn_weights` are added.<br/>
+#1274 ConvTranspose3d does not accept non-uniform kernelSize/stride values<br/>
+
 
 # NuGet Version 0.102.2
 

build/BranchInfo.props

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <MajorVersion>0</MajorVersion>
     <MinorVersion>102</MinorVersion>
-    <PatchVersion>3</PatchVersion>
+    <PatchVersion>5</PatchVersion>
   </PropertyGroup>
 
 </Project>

src/Examples.Utils/Examples.Utils.csproj

@@ -17,7 +17,7 @@
 
   <ItemGroup>
     <PackageReference Include="SharpZipLib" Version="1.4.0" />
-    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.3" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.4" />
   </ItemGroup>
 
   <ItemGroup>

src/Native/LibTorchSharp/THSConvolution.cpp

@@ -278,6 +278,31 @@ NNModule THSNN_ConvTranspose2d_ctor(const int64_t inputChannel, const int64_t ou
     );
 }
 
+NNModule THSNN_ConvTranspose2d_ctor_1(const int64_t inputChannel, const int64_t outputChannel,
+    const int64_t kernelX, const int64_t kernelY,
+    const int64_t strideX, const int64_t strideY,
+    const int64_t paddingX, const int64_t paddingY,
+    const int64_t output_paddingX, const int64_t output_paddingY,
+    const int64_t dilationX, const int64_t dilationY,
+    const int64_t paddingMode, const int64_t groups, const bool bias,
+    NNAnyModule* outAsAnyModule)
+{
+    auto padd = torch::ExpandingArray<2>({ paddingX, paddingY });
+
+    CATCH_RETURN_NNModule(
+        auto opts = torch::nn::ConvTranspose2dOptions(inputChannel, outputChannel, { kernelX, kernelY })
+        .stride({ strideX, strideY })
+        .padding(padd)
+        .dilation({ dilationX, dilationY })
+        .groups(groups)
+        .bias(bias)
+        .output_padding({ output_paddingX, output_paddingY });
+        ApplyPaddingMode(opts, paddingMode);
+
+        res = create_module<torch::nn::ConvTranspose2dImpl>(opts, outAsAnyModule);
+    );
+}
+
 Tensor THSNN_ConvTranspose2d_forward(const NNModule module, const Tensor tensor)
 {
     CATCH_TENSOR((*module)->as<torch::nn::ConvTranspose2d>()->forward(*tensor));
@@ -322,6 +347,31 @@ NNModule THSNN_ConvTranspose3d_ctor(const int64_t inputChannel, const int64_t ou
     );
 }
 
+NNModule THSNN_ConvTranspose3d_ctor_1(const int64_t inputChannel, const int64_t outputChannel,
+    const int64_t kernelX, const int64_t kernelY, const int64_t kernelZ,
+    const int64_t strideX, const int64_t strideY, const int64_t strideZ,
+    const int64_t paddingX, const int64_t paddingY, const int64_t paddingZ,
+    const int64_t output_paddingX, const int64_t output_paddingY, const int64_t output_paddingZ,
+    const int64_t dilationX, const int64_t dilationY, const int64_t dilationZ,
+    const int64_t paddingMode, const int64_t groups, const bool bias,
+    NNAnyModule* outAsAnyModule)
+{
+    auto padd = torch::ExpandingArray<3>({ paddingX, paddingY, paddingZ });
+
+    CATCH_RETURN_NNModule(
+        auto opts = torch::nn::ConvTranspose3dOptions(inputChannel, outputChannel, { kernelX, kernelY, kernelZ })
+        .stride({ strideX, strideY, strideZ })
+        .padding(padd)
+        .dilation({ dilationX, dilationY, dilationZ })
+        .groups(groups)
+        .bias(bias)
+        .output_padding({output_paddingX, output_paddingY, output_paddingZ});
+        ApplyPaddingMode(opts, paddingMode);
+
+        res = create_module<torch::nn::ConvTranspose3dImpl>(opts, outAsAnyModule);
+    );
+}
+
 Tensor THSNN_ConvTranspose3d_bias(const NNModule module)
 {
     return get_bias<torch::nn::ConvTranspose3d>(module);

src/Native/LibTorchSharp/THSNN.h

@@ -67,12 +67,14 @@ EXPORT_API(void)     THSNN_ConvTranspose1d_set_bias(const NNModule module, const
 EXPORT_API(Tensor)   THSNN_ConvTranspose1d_weight(const NNModule module);
 EXPORT_API(void)     THSNN_ConvTranspose1d_set_weight(const NNModule module, const Tensor weight);
 EXPORT_API(NNModule) THSNN_ConvTranspose2d_ctor(const int64_t inputChannel, const int64_t outputChannel, const int64_t kernelSize, const int64_t stride, const int64_t padding, const int64_t output_padding, const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias, NNAnyModule* outAsAnyModule);
+EXPORT_API(NNModule) THSNN_ConvTranspose2d_ctor_1(const int64_t inputChannel, const int64_t outputChannel, const int64_t kernelX, const int64_t kernelY, const int64_t strideX, const int64_t strideY, const int64_t paddingX, const int64_t paddingY, const int64_t output_paddingX, const int64_t output_paddingY, const int64_t dilationX, const int64_t dilationY, const int64_t paddingMode, const int64_t groups, const bool bias, NNAnyModule* outAsAnyModule);
 EXPORT_API(Tensor)   THSNN_ConvTranspose2d_forward(const NNModule module, const Tensor tensor);
 EXPORT_API(Tensor)   THSNN_ConvTranspose2d_weight(const NNModule module);
 EXPORT_API(void)     THSNN_ConvTranspose2d_set_weight(const NNModule module, const Tensor weight);
 EXPORT_API(Tensor)   THSNN_ConvTranspose2d_bias(const NNModule module);
 EXPORT_API(void)     THSNN_ConvTranspose2d_set_bias(const NNModule module, const Tensor bias);
 EXPORT_API(NNModule) THSNN_ConvTranspose3d_ctor(const int64_t inputChannel, const int64_t outputChannel, const int64_t kernelSize, const int64_t stride, const int64_t padding, const int64_t output_padding, const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias, NNAnyModule* outAsAnyModule);
+EXPORT_API(NNModule) THSNN_ConvTranspose3d_ctor_1(const int64_t inputChannel, const int64_t outputChannel, const int64_t kernelX, const int64_t kernelY, const int64_t kernelZ, const int64_t strideX, const int64_t strideY, const int64_t strideZ, const int64_t paddingX, const int64_t paddingY, const int64_t paddingZ, const int64_t output_paddingX, const int64_t output_paddingY, const int64_t output_paddingZ, const int64_t dilationX, const int64_t dilationY, const int64_t dilationZ, const int64_t paddingMode, const int64_t groups, const bool bias, NNAnyModule* outAsAnyModule);
 EXPORT_API(Tensor)   THSNN_ConvTranspose3d_forward(const NNModule module, const Tensor tensor);
 EXPORT_API(Tensor)   THSNN_ConvTranspose3d_weight(const NNModule module);
 EXPORT_API(void)     THSNN_ConvTranspose3d_set_weight(const NNModule module, const Tensor weight);

src/Python/exportsd.py

@@ -37,7 +37,7 @@ def _write_tensor(t, stream):
     stream.write(leb128.u.encode(len(t.shape)))
     for s in t.shape:
         stream.write(leb128.u.encode(s))
-    stream.write(t.numpy().tobytes())
+    stream.write(t.detach().cpu().numpy().tobytes())
 
 def write_tensor(t, file_name):
     f = open(file_name, "wb")

src/TorchAudio/Modules/Wav2Vec2Components.cs

@@ -96,8 +96,8 @@ public ConvLayerBlock(
                 this.stride = stride;
                 this.layer_norm = layer_norm;
                 this.conv = nn.Conv1d(
-                    inputChannel: in_channels,
-                    outputChannel: out_channels,
+                    in_channels: in_channels,
+                    out_channels: out_channels,
                     kernelSize: kernel_size,
                     stride: stride,
                     bias: bias);

src/TorchAudio/Modules/WaveRNN.cs

@@ -248,10 +248,10 @@ protected override void Dispose(bool disposing)
             public ResBlock(string name, int n_freq = 128) : base(name)
             {
                 this.resblock_model = nn.Sequential(
-                    nn.Conv1d(inputChannel: n_freq, outputChannel: n_freq, kernelSize: 1, bias: false),
+                    nn.Conv1d(in_channels: n_freq, out_channels: n_freq, kernelSize: 1, bias: false),
                     nn.BatchNorm1d(n_freq),
                     nn.ReLU(inplace: true),
-                    nn.Conv1d(inputChannel: n_freq, outputChannel: n_freq, kernelSize: 1, bias: false),
+                    nn.Conv1d(in_channels: n_freq, out_channels: n_freq, kernelSize: 1, bias: false),
                     nn.BatchNorm1d(n_freq));
                 RegisterComponents();
             }
@@ -283,13 +283,13 @@ public MelResNet(
                 int kernel_size = 5) : base(name)
             {
                 var modules = new List<nn.Module<Tensor, Tensor>>();
-                modules.Add(nn.Conv1d(inputChannel: n_freq, outputChannel: n_hidden, kernelSize: kernel_size, bias: false));
+                modules.Add(nn.Conv1d(in_channels: n_freq, out_channels: n_hidden, kernelSize: kernel_size, bias: false));
                 modules.Add(nn.BatchNorm1d(n_hidden));
                 modules.Add(nn.ReLU(inplace: true));
                 for (int i = 0; i < n_res_block; i++) {
                     modules.Add(new ResBlock("resblock", n_hidden));
                 }
-                modules.Add(nn.Conv1d(inputChannel: n_hidden, outputChannel: n_output, kernelSize: 1));
+                modules.Add(nn.Conv1d(in_channels: n_hidden, out_channels: n_output, kernelSize: 1));
                 this.melresnet_model = nn.Sequential(modules);
                 RegisterComponents();
             }
@@ -358,7 +358,7 @@ public UpsampleNetwork(
                 var up_layers = new List<nn.Module<Tensor, Tensor>>();
                 foreach (var scale in upsample_scales) {
                     var stretch = new Stretch2d("stretch2d", scale, 1);
-                    var conv = nn.Conv2d(inputChannel: 1, outputChannel: 1, kernelSize: (1, scale * 2 + 1), padding: (0, scale), bias: false);
+                    var conv = nn.Conv2d(in_channels: 1, out_channels: 1, kernelSize: (1, scale * 2 + 1), padding: (0, scale), bias: false);
                     torch.nn.init.constant_(conv.weight, 1.0 / (scale * 2 + 1));
                     up_layers.Add(stretch);
                     up_layers.Add(conv);

src/TorchSharp/NN/Convolution/Conv1D.cs

@@ -97,45 +97,45 @@ public static partial class nn
             /// <summary>
             /// Applies a 1D convolution over an input signal composed of several input planes.
             /// </summary>
-            /// <param name="inputChannel">Number of channels in the input image</param>
-            /// <param name="outputChannel">Number of channels produced by the convolution</param>
+            /// <param name="in_channels">Number of channels in the input image</param>
+            /// <param name="out_channels">Number of channels produced by the convolution</param>
             /// <param name="kernelSize">Size of the convolving kernel</param>
             /// <param name="stride">Stride of the convolution. Default: 1</param>
             /// <param name="padding">Zero-padding added to both sides of the input. Default: 0</param>
             /// <param name="dilation">Spacing between kernel elements. Default: 1</param>
-            /// <param name="paddingMode">'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'</param>
+            /// <param name="padding_mode">'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'</param>
             /// <param name="groups">Number of blocked connections from input channels to output channels. Default: 1</param>
             /// <param name="bias">If true, adds a learnable bias to the output. Default: true</param>
             /// <param name="device">The desired device of the parameters and buffers in this module</param>
             /// <param name="dtype">The desired floating point or complex dtype of the parameters and buffers in this module</param>
             /// <returns>Tensor of shape (N,C_out,L_out)</returns>
-            public static Conv1d Conv1d(long inputChannel, long outputChannel, long kernelSize, long stride = 1, long padding = 0, long dilation = 1, PaddingModes paddingMode = PaddingModes.Zeros, long groups = 1, bool bias = true, Device? device = null, ScalarType? dtype = null)
+            public static Conv1d Conv1d(long in_channels, long out_channels, long kernelSize, long stride = 1, long padding = 0, long dilation = 1, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1, bool bias = true, Device? device = null, ScalarType? dtype = null)
             {
-                var res = THSNN_Conv1d_ctor(inputChannel, outputChannel, kernelSize, stride, padding, dilation, (long)paddingMode, groups, bias, out var boxedHandle);
+                var res = THSNN_Conv1d_ctor(in_channels, out_channels, kernelSize, stride, padding, dilation, (long)padding_mode, groups, bias, out var boxedHandle);
                 if (res == IntPtr.Zero) { torch.CheckForErrors(); }
-                return new Conv1d(res, boxedHandle, inputChannel).MoveModule<Conv1d>(device, dtype);
+                return new Conv1d(res, boxedHandle, in_channels).MoveModule<Conv1d>(device, dtype);
             }
 
             /// <summary>
             /// Applies a 1D convolution over an input signal composed of several input planes.
             /// </summary>
-            /// <param name="inputChannel">Number of channels in the input image</param>
-            /// <param name="outputChannel">Number of channels produced by the convolution</param>
+            /// <param name="in_channels">Number of channels in the input image</param>
+            /// <param name="out_channels">Number of channels produced by the convolution</param>
             /// <param name="kernelSize">Size of the convolving kernel</param>
             /// <param name="stride">Stride of the convolution. Default: 1</param>
             /// <param name="padding">Zero-padding added to both sides of the input. padding=Valid is the same as no padding. padding=Same pads the input so the output has the shape as the input. </param>
             /// <param name="dilation">Spacing between kernel elements. Default: 1</param>
-            /// <param name="paddingMode">'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'</param>
+            /// <param name="padding_mode">'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'</param>
             /// <param name="groups">Number of blocked connections from input channels to output channels. Default: 1</param>
             /// <param name="bias">If true, adds a learnable bias to the output. Default: true</param>
             /// <param name="device">The desired device of the parameters and buffers in this module</param>
             /// <param name="dtype">The desired floating point or complex dtype of the parameters and buffers in this module</param>
             /// <returns>Tensor of shape (N,C_out,L_out)</returns>
-            public static Conv1d Conv1d(long inputChannel, long outputChannel, long kernelSize, Padding padding, long stride = 1, long dilation = 1, PaddingModes paddingMode = PaddingModes.Zeros, long groups = 1, bool bias = true, Device? device = null, ScalarType? dtype = null)
+            public static Conv1d Conv1d(long in_channels, long out_channels, long kernelSize, Padding padding, long stride = 1, long dilation = 1, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1, bool bias = true, Device? device = null, ScalarType? dtype = null)
             {
-                var res = THSNN_Conv1d_ctor(inputChannel, outputChannel, kernelSize, stride, padding == Padding.Valid ? 0 : -1, dilation, (long)paddingMode, groups, bias, out var boxedHandle);
+                var res = THSNN_Conv1d_ctor(in_channels, out_channels, kernelSize, stride, padding == Padding.Valid ? 0 : -1, dilation, (long)padding_mode, groups, bias, out var boxedHandle);
                 if (res == IntPtr.Zero) { torch.CheckForErrors(); }
-                return new Conv1d(res, boxedHandle, inputChannel).MoveModule<Conv1d>(device, dtype);
+                return new Conv1d(res, boxedHandle, in_channels).MoveModule<Conv1d>(device, dtype);
             }
 
             public static partial class functional