Merge branch 'unit' of https://github.com/NiklasGustafsson/TorchSharp into unit

Author: NiklasGustafsson

src/Native/LibTorchSharp/CMakeLists.txt

@@ -22,8 +22,7 @@ set(SOURCES
 	crc32c.c
 	THSActivation.cpp
     THSAutograd.cpp
-	THSConvolution.cpp
-    THSData.cpp
+	THSData.cpp
 	THSFFT.cpp
     THSJIT.cpp
 	THSLinearAlgebra.cpp

src/Native/LibTorchSharp/THSNN.h

@@ -37,50 +37,6 @@ EXPORT_API(void)        THSNN_AnyModule_dispose(const NNAnyModule module);
 
 EXPORT_API(NNModule) THSNN_custom_module(const char* name, Tensor(*forward)(Tensor), NNAnyModule* outAsAnyModule);
 
-// Convolution
-
-EXPORT_API(NNModule) THSNN_Conv1d_ctor(const int64_t inputChannel, const int64_t outputChannel, const int64_t kernelSize, const int64_t stride, const int64_t padding, const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias, NNAnyModule* outAsAnyModule);
-EXPORT_API(Tensor)   THSNN_Conv1d_forward(const NNModule module, const Tensor tensor);
-EXPORT_API(Tensor)   THSNN_Conv1d_bias(const NNModule module);
-EXPORT_API(void)     THSNN_Conv1d_set_bias(const NNModule module, const Tensor bias);
-EXPORT_API(Tensor)   THSNN_Conv1d_weight(const NNModule module);
-EXPORT_API(void)     THSNN_Conv1d_set_weight(const NNModule module, const Tensor weight);
-EXPORT_API(NNModule) THSNN_Conv2d_ctor(const int64_t inputChannel, const int64_t outputChannel, const int64_t kernelSize, const int64_t stride, const int64_t padding, const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias, NNAnyModule* outAsAnyModule);
-EXPORT_API(NNModule) THSNN_Conv2d_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 dilationX, const int64_t dilationY, const int64_t paddingMode, const int64_t groups, const bool bias, NNAnyModule* outAsAnyModule);
-EXPORT_API(Tensor)   THSNN_Conv2d_forward(const NNModule module, const Tensor tensor);
-EXPORT_API(Tensor)   THSNN_Conv2d_weight(const NNModule module);
-EXPORT_API(void)     THSNN_Conv2d_set_weight(const NNModule module, const Tensor weight);
-EXPORT_API(Tensor)   THSNN_Conv2d_bias(const NNModule module);
-EXPORT_API(void)     THSNN_Conv2d_set_bias(const NNModule module, const Tensor bias);
-EXPORT_API(NNModule) THSNN_Conv3d_ctor(const int64_t inputChannel, const int64_t outputChannel, const int64_t kernelSize, const int64_t stride, const int64_t padding, const int64_t dilation, const int64_t paddingMode, const int64_t groups, const bool bias, NNAnyModule* outAsAnyModule);
-EXPORT_API(NNModule) THSNN_Conv3d_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 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_Conv3d_forward(const NNModule module, const Tensor tensor);
-EXPORT_API(Tensor)   THSNN_Conv3d_weight(const NNModule module);
-EXPORT_API(void)     THSNN_Conv3d_set_weight(const NNModule module, const Tensor weight);
-EXPORT_API(Tensor)   THSNN_Conv3d_bias(const NNModule module);
-EXPORT_API(void)     THSNN_Conv3d_set_bias(const NNModule module, const Tensor bias);
-
-EXPORT_API(NNModule) THSNN_ConvTranspose1d_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(Tensor)   THSNN_ConvTranspose1d_forward(const NNModule module, const Tensor tensor);
-EXPORT_API(Tensor)   THSNN_ConvTranspose1d_bias(const NNModule module);
-EXPORT_API(void)     THSNN_ConvTranspose1d_set_bias(const NNModule module, const Tensor bias);
-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);
-EXPORT_API(Tensor)   THSNN_ConvTranspose3d_bias(const NNModule module);
-EXPORT_API(void)     THSNN_ConvTranspose3d_set_bias(const NNModule module, const Tensor bias);
-
 // Normalization
 
 EXPORT_API(Tensor)   THSNN_batch_norm(const Tensor input, const Tensor running_mean, const Tensor running_var, const Tensor weight, const Tensor bias, const bool training, const double momentum, const double eps);

src/Native/LibTorchSharp/THSTensor.h

@@ -314,6 +314,24 @@ EXPORT_API(Tensor) THSTensor_conv3d(const Tensor input, const Tensor weight, con
     const int64_t* dilations, const int dilations_length,
     int64_t groups);
 
+EXPORT_API(Tensor) THSTensor_conv1d_padding(const Tensor input, const Tensor weight, const Tensor bias,
+    const int64_t* strides, const int strides_length,
+    const int padding,
+    const int64_t* dilations, const int dilations_length,
+    int64_t groups);
+
+EXPORT_API(Tensor) THSTensor_conv2d_padding(const Tensor input, const Tensor weight, const Tensor bias,
+    const int64_t* strides, const int strides_length,
+    const int padding,
+    const int64_t* dilations, const int dilations_length,
+    int64_t groups);
+
+EXPORT_API(Tensor) THSTensor_conv3d_padding(const Tensor input, const Tensor weight, const Tensor bias,
+    const int64_t* strides, const int strides_length,
+    const int padding,
+    const int64_t* dilations, const int dilations_length,
+    int64_t groups);
+
 EXPORT_API(Tensor) THSTensor_conv_transpose1d(const Tensor input, const Tensor weight, const Tensor bias,
     const int64_t* strides, const int strides_length,
     const int64_t* paddings, const int paddings_length,

src/Native/LibTorchSharp/THSTensorConv.cpp

@@ -340,6 +340,63 @@ Tensor THSTensor_conv3d(
         groups));
 }
 
+static c10::string_view get_padding_str(int padding) {
+    if (padding == 0)
+        return "valid";
+    else if (padding == 1)
+        return "same";
+
+    TORCH_CHECK(false, "Invalid padding string specified");
+}
+
+Tensor THSTensor_conv1d_padding(
+    const Tensor input,
+    const Tensor weight,
+    const Tensor bias,
+    const int64_t* stride, const int strideLength,
+    const int padding,
+    const int64_t* dilation, const int dilationLength,
+    int64_t groups)
+{
+    CATCH_TENSOR(torch::conv1d(*input, *weight, (bias ? *bias : at::Tensor()),
+        at::ArrayRef<int64_t>(stride, strideLength),
+        get_padding_str(padding),
+        at::ArrayRef<int64_t>(dilation, dilationLength),
+        groups));
+}
+
+
+Tensor THSTensor_conv2d_padding(
+    const Tensor input,
+    const Tensor weight,
+    const Tensor bias,
+    const int64_t* stride, const int strideLength,
+    const int padding,
+    const int64_t* dilation, const int dilationLength,
+    int64_t groups)
+{
+    CATCH_TENSOR(torch::conv2d(*input, *weight, (bias ? *bias : at::Tensor()),
+        at::ArrayRef<int64_t>(stride, strideLength),
+        get_padding_str(padding),
+        at::ArrayRef<int64_t>(dilation, dilationLength),
+        groups));
+}
+
+Tensor THSTensor_conv3d_padding(
+    const Tensor input,
+    const Tensor weight,
+    const Tensor bias,
+    const int64_t* stride, const int strideLength,
+    const int padding,
+    const int64_t* dilation, const int dilationLength,
+    int64_t groups)
+{
+    CATCH_TENSOR(torch::conv3d(*input, *weight, (bias ? *bias : at::Tensor()),
+        at::ArrayRef<int64_t>(stride, strideLength),
+        get_padding_str(padding),
+        at::ArrayRef<int64_t>(dilation, dilationLength),
+        groups));
+}
 
 Tensor THSTensor_max_pool1d(
     const Tensor tensor,

src/TorchSharp/NN/Convolution/Conv1D.cs

@@ -8,84 +8,27 @@ namespace TorchSharp
 {
     using Modules;
 
-    public enum PaddingModes
-    {
-        Zeros = 0,
-        Reflect = 1,
-        Replicate = 2,
-        Circular = 3,
-        Constant = 4,
-    }
-
-    public enum Padding
-    {
-        Valid = 0,
-        Same = 1
-    }
-
     namespace Modules
     {
-        public abstract class Convolution : torch.nn.Module<Tensor, Tensor>
-        {
-            protected Convolution(IntPtr handle, IntPtr boxedHandle, long input_channels) : base(handle, boxedHandle)
-            {
-                this.input_channels = input_channels;
-            }
-
-            protected bool ValidateShape(Tensor input, long dimensions)
-            {
-                var shape = input.shape;
-                var ndim = shape.LongLength;
-
-                return (ndim == dimensions+2) && (input.shape[1] == input_channels) ||  // Batched: N + C + dims
-                       (ndim == dimensions+1 && input.shape[0] == input_channels);      // Unbathced: C + dims
-
-            }
-
-            protected long input_channels;
-        }
-
         public sealed class Conv1d : Convolution
         {
-            internal Conv1d(IntPtr handle, IntPtr boxedHandle, long input_channels) : base(handle, boxedHandle, input_channels) { }
+            internal Conv1d(long in_channels, long out_channels, long kernel_size, long stride, long? padding, Padding? padding_type, long dilation, long groups = 1, bool bias = true, PaddingModes padding_mode = PaddingModes.Zeros, torch.Device? device = null, ScalarType? dtype = null)
+                        : base(nameof(Conv1d), in_channels, out_channels, new[] { kernel_size }, new[] { stride }, padding.HasValue ? new[] { padding.Value } : null, padding_type, new[] { dilation }, false, new[] { 0L }, groups, bias, padding_mode, device, dtype) { }
 
             public override Tensor forward(Tensor input)
             {
-                if (ValidateShape(input, 1)) {
-                    var res = THSNN_Conv1d_forward(handle, input.Handle);
-                    if (res == IntPtr.Zero) { torch.CheckForErrors(); }
-                    return new Tensor(res);
-                }
-                throw new ArgumentException($"Expected 2D (unbatched) or 3D (batched) input with {input_channels} channels to Conv1d.");
-            }
+                if (!ValidateShape(input, 1)) 
+                    throw new ArgumentException($"Expected 2D (unbatched) or 3D (batched) input with {in_channels} channels to Conv1d.");
 
-            public Parameter? bias {
-                get {
-                    var res = THSNN_Conv1d_bias(handle);
-                    if (res == IntPtr.Zero) { torch.CheckForErrors(); }
-                    return ((res == IntPtr.Zero) ? null : new Parameter(res));
-                }
-                set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("bias cannot be set to 'null'");
-                    THSNN_Conv1d_set_bias(handle, (value is null ? IntPtr.Zero : value.Handle));
-                    torch.CheckForErrors();
-                    ConditionallyRegisterParameter("bias", value);
-                }
-            }
-            public Parameter? weight {
-                get {
-                    var res = THSNN_Conv1d_weight(handle);
-                    if (res == IntPtr.Zero) { torch.CheckForErrors(); }
-                    return (res == IntPtr.Zero) ? null : new Parameter(res);
-                }
-                set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("weight cannot be set to 'null'");
-                    THSNN_Conv1d_set_weight(handle, value is null ? IntPtr.Zero : value.Handle);
-                    torch.CheckForErrors();
-                    ConditionallyRegisterParameter("weight", value);
+                if (padding_mode != PaddingModes.Zeros) {
+                    using var paddedInput = torch.nn.functional.pad(input, _reversed_padding_repeated_twice, padding_mode);
+                    return torch.nn.functional.conv1d(paddedInput, weight, bias, stride[0], 0, dilation[0], groups);
                 }
+
+                if (padding_type.HasValue)
+                    return torch.nn.functional.conv1d_padding(input, weight, bias, stride[0], padding_type.Value, dilation[0], groups);
+
+                return torch.nn.functional.conv1d(input, weight, bias, stride[0], padding?[0], dilation[0], groups);
             }
         }
     }
@@ -111,9 +54,7 @@ public static partial class nn
             /// <returns>Tensor of shape (N,C_out,L_out)</returns>
             public static Conv1d Conv1d(long in_channels, long out_channels, long kernel_size, 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(in_channels, out_channels, kernel_size, stride, padding, dilation, (long)padding_mode, groups, bias, out var boxedHandle);
-                if (res == IntPtr.Zero) { torch.CheckForErrors(); }
-                return new Conv1d(res, boxedHandle, in_channels).MoveModule<Conv1d>(device, dtype);
+                return new Conv1d(in_channels, out_channels, kernel_size, stride, padding, null, dilation, groups, bias, padding_mode, device, dtype);
             }
 
             /// <summary>
@@ -133,9 +74,7 @@ public static Conv1d Conv1d(long in_channels, long out_channels, long kernel_siz
             /// <returns>Tensor of shape (N,C_out,L_out)</returns>
             public static Conv1d Conv1d(long in_channels, long out_channels, long kernel_size, 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(in_channels, out_channels, kernel_size, 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, in_channels).MoveModule<Conv1d>(device, dtype);
+                return new Conv1d(in_channels, out_channels, kernel_size, stride, null, padding, dilation, groups, bias, padding_mode, device, dtype);
             }
 
             public static partial class functional
@@ -144,12 +83,12 @@ public static partial class functional
                 /// Applies a 1D convolution over an input signal composed of several input planes.
                 /// </summary>
                 /// <param name="input">The input tensor.</param>
-                /// <param name="weight"></param>
-                /// <param name="bias"></param>
-                /// <param name="stride"></param>
-                /// <param name="padding"></param>
-                /// <param name="dilation"></param>
-                /// <param name="groups"></param>
+                /// <param name="weight">weight matrix of the convolution</param>
+                /// <param name="bias">Optional; bias vector of the convolution</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="groups">Number of blocked connections from input channels to output channels. Default: 1</param>
                 /// <returns></returns>
                 public static Tensor conv1d(Tensor input, Tensor weight, Tensor? bias = null,
                     long? stride = null,
@@ -175,6 +114,39 @@ public static Tensor conv1d(Tensor input, Tensor weight, Tensor? bias = null,
                     }
                 }
 
+                /// <summary>
+                /// Applies a 1D convolution over an input signal composed of several input planes.
+                /// </summary>
+                /// <param name="input">The input tensor.</param>
+                /// <param name="weight">weight matrix of the convolution</param>
+                /// <param name="bias">Optional; bias vector of the convolution</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="groups">Number of blocked connections from input channels to output channels. Default: 1</param>
+                /// <returns></returns>
+                public static Tensor conv1d_padding(Tensor input, Tensor weight, Tensor? bias = null,
+                    long? stride = null,
+                    Padding padding = Padding.Valid,
+                    long? dilation = null,
+                    long groups = 1)
+                {
+                    var strides = new long[] { stride ?? 1 };
+                    var dilationArray = new long[] { dilation ?? 1 };
+                    var biasHandle = (bias is null ? IntPtr.Zero : bias.Handle);
+                    unsafe {
+                        fixed (long* pstrides = strides, pdilation = dilationArray) {
+                            var res =
+                                THSTensor_conv1d_padding(input.Handle, weight.Handle, biasHandle,
+                                    (IntPtr)pstrides, strides.Length,
+                                    (int)padding,
+                                    (IntPtr)pdilation, dilationArray.Length,
+                                    groups);
+                            if (res == IntPtr.Zero) { torch.CheckForErrors(); }
+                            return new Tensor(res);
+                        }
+                    }
+                }
             }
         }
     }