Moving more modules to C#.

src/Examples/AlexNet.cs

@@ -19,17 +19,17 @@ public AlexNet(string name, int numClasses, torch.Device device = null) : base(n
             features = Sequential(
                 ("c1", Conv2d(3, 64, kernelSize: 3, stride: 2, padding: 1)),
                 ("r1", ReLU(inplace: true)),
-                ("mp1", MaxPool2d(kernelSize: new long[] { 2, 2 })),
+                ("mp1", MaxPool2d(kernel_size: new long[] { 2, 2 })),
                 ("c2", Conv2d(64, 192, kernelSize: 3, padding: 1)),
                 ("r2", ReLU(inplace: true)),
-                ("mp2", MaxPool2d(kernelSize: new long[] { 2, 2 })),
+                ("mp2", MaxPool2d(kernel_size: new long[] { 2, 2 })),
                 ("c3", Conv2d(192, 384, kernelSize: 3, padding: 1)),
                 ("r3", ReLU(inplace: true)),
                 ("c4", Conv2d(384, 256, kernelSize: 3, padding: 1)),
                 ("r4", ReLU(inplace: true)),
                 ("c5", Conv2d(256, 256, kernelSize: 3, padding: 1)),
                 ("r5", ReLU(inplace: true)),
-                ("mp3", MaxPool2d(kernelSize: new long[] { 2, 2 })));
+                ("mp3", MaxPool2d(kernel_size: new long[] { 2, 2 })));
 
             avgPool = AdaptiveAvgPool2d(new long[] { 2, 2 });
 

src/Examples/MNIST.cs

@@ -105,7 +105,7 @@ internal class Model : Module<Tensor, Tensor>
 
             // These don't have any parameters, so the only reason to instantiate
             // them is performance, since they will be used over and over.
-            private Module<Tensor, Tensor> pool1 = MaxPool2d(kernelSize: new long[] { 2, 2 });
+            private Module<Tensor, Tensor> pool1 = MaxPool2d(kernel_size: new long[] { 2, 2 });
 
             private Module<Tensor, Tensor> relu1 = ReLU();
             private Module<Tensor, Tensor> relu2 = ReLU();

src/Examples/VGG.cs

@@ -38,7 +38,7 @@ public VGG(string name, int numClasses, Device device = null) : base(name)
             for (var i = 0; i < channels.Length; i++) {
 
                 if (channels[i] == 0) {
-                    modules.Add(($"MaxPool2d-{i}a", MaxPool2d(kernelSize: 2, stride: 2)));
+                    modules.Add(($"MaxPool2d-{i}a", MaxPool2d(kernel_size: 2, stride: 2)));
                 } else {
                     modules.Add(($"conv2d-{i}a", Conv2d(in_channels, channels[i], kernelSize: 3, padding: 1)));
                     modules.Add(($"bnrm2d-{i}a", BatchNorm2d(channels[i])));

src/FSharp.Examples/AlexNet.fs

@@ -49,17 +49,17 @@ type Model(name,device:torch.Device) as this =
 
     let features = Sequential(("c1", Conv2d(3L, 64L, kernelSize=3L, stride=2L, padding=1L) :> Module<torch.Tensor,torch.Tensor>),
                               ("r1", ReLU(inplace=true) :> Module<torch.Tensor,torch.Tensor>),
-                              ("mp1", MaxPool2d(kernelSize=[|2L; 2L|]) :> Module<torch.Tensor,torch.Tensor>),
+                              ("mp1", MaxPool2d(kernel_size=[|2L; 2L|]) :> Module<torch.Tensor,torch.Tensor>),
                               ("c2", Conv2d(64L, 192L, kernelSize=3L, padding=1L) :> Module<torch.Tensor,torch.Tensor>),
                               ("r2", ReLU(inplace=true) :> Module<torch.Tensor,torch.Tensor>),
-                              ("mp2", MaxPool2d(kernelSize=[|2L; 2L|]) :> Module<torch.Tensor,torch.Tensor>),
+                              ("mp2", MaxPool2d(kernel_size=[|2L; 2L|]) :> Module<torch.Tensor,torch.Tensor>),
                               ("c3", Conv2d(192L, 384L, kernelSize=3L, padding=1L) :> Module<torch.Tensor,torch.Tensor>),
                               ("r3", ReLU(inplace=true) :> Module<torch.Tensor,torch.Tensor>),
                               ("c4", Conv2d(384L, 256L, kernelSize=3L, padding=1L) :> Module<torch.Tensor,torch.Tensor>),
                               ("r4", ReLU(inplace=true) :> Module<torch.Tensor,torch.Tensor>),
                               ("c5", Conv2d(256L, 256L, kernelSize=3L, padding=1L) :> Module<torch.Tensor,torch.Tensor>),
                               ("r5", ReLU(inplace=true) :> Module<torch.Tensor,torch.Tensor>),
-                              ("mp3", MaxPool2d(kernelSize=[|2L; 2L|]) :> Module<torch.Tensor,torch.Tensor>),
+                              ("mp3", MaxPool2d(kernel_size=[|2L; 2L|]) :> Module<torch.Tensor,torch.Tensor>),
                               ("avg", AdaptiveAvgPool2d([|2L; 2L|]) :> Module<torch.Tensor,torch.Tensor>))
 
     let classifier = Sequential(("d1", Dropout() :> Module<torch.Tensor,torch.Tensor>),

src/FSharp.Examples/MNIST.fs

@@ -51,7 +51,7 @@ type Model(name,device:torch.Device) as this =
     let fc1 = Linear(9216L, 128L)
     let fc2 = Linear(128L, 10L)
 
-    let pool1 = MaxPool2d(kernelSize=[|2L; 2L|])
+    let pool1 = MaxPool2d(kernel_size=[|2L; 2L|])
 
     let relu = ReLU()
 

src/Native/LibTorchSharp/THSActivation.cpp

@@ -2,330 +2,3 @@
 #include "THSNN.h"
 
 #include <torch/nn/init.h>
-
-NNModule THSNN_CELU_ctor(const double alpha, const bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::CELUOptions().alpha(alpha).inplace(inplace);
-        res = create_module<torch::nn::CELUImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_CELU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::CELU>()->forward(*tensor));
-}
-
-NNModule THSNN_ELU_ctor(const double alpha, const bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::ELUOptions().alpha(alpha).inplace(inplace);
-        res = create_module<torch::nn::ELUImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_ELU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::ELU>()->forward(*tensor));
-}
-
-NNModule THSNN_GELU_ctor(NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        res = create_module<torch::nn::GELUImpl>(outAsAnyModule);
-    );
-}
-
-Tensor THSNN_GELU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::GELU>()->forward(*tensor));
-}
-
-NNModule THSNN_GLU_ctor(const int64_t dim, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::GLUOptions().dim(dim);
-        res = create_module<torch::nn::GLUImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor   THSNN_GLU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::GLU>()->forward(*tensor));
-}
-
-NNModule THSNN_Hardshrink_ctor(const double lambda, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::HardshrinkOptions(lambda);
-        res = create_module<torch::nn::HardshrinkImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor   THSNN_Hardshrink_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::Hardshrink>()->forward(*tensor));
-}
-
-NNModule THSNN_Hardtanh_ctor(const double min_val, const double max_val, const bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::HardtanhOptions()
-            .min_val(min_val)
-            .max_val(max_val)
-            .inplace(inplace);
-        res = create_module<torch::nn::HardtanhImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor   THSNN_Hardtanh_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::Hardtanh>()->forward(*tensor));
-}
-
-
-NNModule THSNN_LeakyReLU_ctor(const double negative_sloope, const bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::LeakyReLUOptions().negative_slope(negative_sloope).inplace(inplace);
-        res = create_module<torch::nn::LeakyReLUImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_LeakyReLU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::LeakyReLU>()->forward(*tensor));
-}
-
-NNModule THSNN_LogSoftmax_ctor(int64_t dim, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::LogSoftmaxOptions(dim);
-        res = create_module<torch::nn::LogSoftmaxImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_LogSoftmax_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::LogSoftmax>()->forward(*tensor));
-}
-
-NNModule THSNN_Mish_ctor(NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        res = create_module<torch::nn::MishImpl>(outAsAnyModule);
-    );
-}
-
-Tensor THSNN_Mish_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::Mish>()->forward(*tensor));
-}
-
-NNModule THSNN_PReLU_ctor(const int64_t nparams, const double init, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::PReLUOptions().num_parameters(nparams).init(init);
-        res = create_module<torch::nn::PReLUImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_PReLU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::PReLU>()->forward(*tensor));
-}
-
-Tensor THSNN_PReLU_weight(const NNModule module)
-{
-    return get_weight<torch::nn::PReLU>(module);
-}
-
-void THSNN_PReLU_set_weight(const NNModule module, const Tensor weight)
-{
-    set_weight<torch::nn::PReLU>(module, weight);
-}
-
-NNModule THSNN_ReLU_ctor(bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::ReLUOptions(inplace);
-        res = create_module<torch::nn::ReLUImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_ReLU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::ReLU>()->forward(*tensor));
-}
-
-NNModule THSNN_RReLU_ctor(const double lower, const double upper, const bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::RReLUOptions().lower(lower).upper(upper).inplace(inplace);
-        res = create_module<torch::nn::RReLUImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_RReLU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::RReLU>()->forward(*tensor));
-}
-
-NNModule THSNN_ReLU6_ctor(bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::ReLU6Options(inplace);
-        res = create_module<torch::nn::ReLU6Impl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_ReLU6_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::ReLU6>()->forward(*tensor));
-}
-
-NNModule THSNN_SELU_ctor(bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::SELUOptions(inplace);
-        res = create_module<torch::nn::SELUImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_SELU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::SELU>()->forward(*tensor));
-}
-
-NNModule THSNN_Sigmoid_ctor(NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        res = create_module<torch::nn::SigmoidImpl>(outAsAnyModule);
-    );
-}
-
-Tensor THSNN_Sigmoid_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::Sigmoid>()->forward(*tensor));
-}
-
-NNModule THSNN_SiLU_ctor(NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        res = create_module<torch::nn::SiLUImpl>(outAsAnyModule);
-    );
-}
-
-Tensor THSNN_SiLU_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::SiLU>()->forward(*tensor));
-}
-
-NNModule THSNN_Softmax2d_ctor(NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        res = create_module<torch::nn::Softmax2dImpl>(outAsAnyModule);
-    );
-}
-
-Tensor THSNN_Softmax2d_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::Softmax2d>()->forward(*tensor));
-}
-
-NNModule THSNN_Softmax_ctor(const int64_t dim, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::SoftmaxOptions(dim);
-        res = create_module<torch::nn::SoftmaxImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_Softmax_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::Softmax>()->forward(*tensor));
-}
-
-NNModule THSNN_Softmin_ctor(const int64_t dim, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::SoftminOptions(dim);
-        res = create_module<torch::nn::SoftminImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor THSNN_Softmin_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::Softmin>()->forward(*tensor));
-}
-
-NNModule THSNN_Softplus_ctor(const double beta, const double threshold, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::SoftplusOptions().beta(beta).threshold(threshold);
-        res = create_module<torch::nn::SoftplusImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor   THSNN_Softplus_forward(const NNModule module, const Tensor tensor) {
-    CATCH_TENSOR((*module)->as<torch::nn::Softplus>()->forward(*tensor));
-}
-
-NNModule THSNN_Softshrink_ctor(const double lambda, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::SoftshrinkOptions().lambda(lambda);
-        res = create_module<torch::nn::SoftshrinkImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor   THSNN_Softshrink_forward(const NNModule module, const Tensor tensor) {
-    CATCH_TENSOR((*module)->as<torch::nn::Softshrink>()->forward(*tensor));
-}
-
-NNModule THSNN_Softsign_ctor(NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        res = create_module<torch::nn::SoftsignImpl>(outAsAnyModule);
-    );
-}
-
-Tensor   THSNN_Softsign_forward(const NNModule module, const Tensor tensor) {
-    CATCH_TENSOR((*module)->as<torch::nn::Softsign>()->forward(*tensor));
-}
-
-NNModule THSNN_Tanh_ctor(NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        res = create_module<torch::nn::TanhImpl>(outAsAnyModule);
-    );
-}
-
-Tensor THSNN_Tanh_forward(const NNModule module, const Tensor tensor)
-{
-    CATCH_TENSOR((*module)->as<torch::nn::Tanh>()->forward(*tensor));
-}
-
-NNModule THSNN_Tanhshrink_ctor(NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        res = create_module<torch::nn::TanhshrinkImpl>(outAsAnyModule);
-    );
-}
-
-Tensor   THSNN_Tanhshrink_forward(const NNModule module, const Tensor tensor) {
-    CATCH_TENSOR((*module)->as<torch::nn::Tanhshrink>()->forward(*tensor));
-}
-
-NNModule THSNN_Threshold_ctor(const double threshold, const double value, const bool inplace, NNAnyModule* outAsAnyModule)
-{
-    CATCH_RETURN_NNModule(
-        auto opts = torch::nn::ThresholdOptions(threshold, value).inplace(inplace);
-        res = create_module<torch::nn::ThresholdImpl>(opts, outAsAnyModule);
-    );
-}
-
-Tensor   THSNN_Threshold_forward(const NNModule module, const Tensor tensor) {
-    CATCH_TENSOR((*module)->as<torch::nn::Threshold>()->forward(*tensor));
-}
-