torch-rb 0.2.0 → 0.2.5

data/lib/torch/utils/data/data_loader.rb

@@ -6,21 +6,49 @@ module Torch
 
         attr_reader :dataset
 
-        def initialize(dataset, batch_size: 1)
+        def initialize(dataset, batch_size: 1, shuffle: false)
           @dataset = dataset
           @batch_size = batch_size
+          @shuffle = shuffle
         end
 
         def each
-          size.times do |i|
-            start_index = i * @batch_size
-            yield @dataset[start_index...(start_index + @batch_size)]
+          # try to keep the random number generator in sync with Python
+          # this makes it easy to compare results
+          base_seed = Torch.empty([], dtype: :int64).random!.item
+
+          indexes =
+            if @shuffle
+              Torch.randperm(@dataset.size).to_a
+            else
+              @dataset.size.times
+            end
+
+          indexes.each_slice(@batch_size) do |idx|
+            batch = idx.map { |i| @dataset[i] }
+            yield collate(batch)
           end
         end
 
         def size
           (@dataset.size / @batch_size.to_f).ceil
         end
+
+        private
+
+        def collate(batch)
+          elem = batch[0]
+          case elem
+          when Tensor
+            Torch.stack(batch, 0)
+          when Integer
+            Torch.tensor(batch)
+          when Array
+            batch.transpose.map { |v| collate(v) }
+          else
+            raise NotImpelmentYet
+          end
+        end
       end
     end
   end

data/lib/torch/utils/data/dataset.rb

@@ -0,0 +1,8 @@
+module Torch
+  module Utils
+    module Data
+      class Dataset
+      end
+    end
+  end
+end

data/lib/torch/utils/data/tensor_dataset.rb

@@ -1,7 +1,7 @@
 module Torch
   module Utils
     module Data
-      class TensorDataset
+      class TensorDataset < Dataset
         def initialize(*tensors)
           unless tensors.all? { |t| t.size(0) == tensors[0].size(0) }
             raise Error, "Tensors must all have same dim 0 size"

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.2.0"
+  VERSION = "0.2.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.5
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-23 00:00:00.000000000 Z
+date: 2020-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -95,19 +95,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: npy
+  name: torchvision
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
 description: 
 email: andrew@chartkick.com
 executables: []
@@ -120,17 +120,10 @@ files:
 - README.md
 - ext/torch/ext.cpp
 - ext/torch/extconf.rb
-- ext/torch/nn_functions.cpp
-- ext/torch/nn_functions.hpp
 - ext/torch/templates.cpp
 - ext/torch/templates.hpp
-- ext/torch/tensor_functions.cpp
-- ext/torch/tensor_functions.hpp
-- ext/torch/torch_functions.cpp
-- ext/torch/torch_functions.hpp
 - lib/torch-rb.rb
 - lib/torch.rb
-- lib/torch/ext.bundle
 - lib/torch/hub.rb
 - lib/torch/inspector.rb
 - lib/torch/native/dispatcher.rb
@@ -265,9 +258,9 @@ files:
 - lib/torch/optim/rmsprop.rb
 - lib/torch/optim/rprop.rb
 - lib/torch/optim/sgd.rb
-- lib/torch/random.rb
 - lib/torch/tensor.rb
 - lib/torch/utils/data/data_loader.rb
+- lib/torch/utils/data/dataset.rb
 - lib/torch/utils/data/tensor_dataset.rb
 - lib/torch/version.rb
 homepage: https://github.com/ankane/torch.rb

data/ext/torch/nn_functions.cpp

@@ -1,560 +0,0 @@
-// generated by rake generate:functions
-// do not edit by hand
-
-#include <torch/torch.h>
-#include <rice/Module.hpp>
-#include "templates.hpp"
-
-void add_nn_functions(Module m) {
-  m
-  .define_singleton_method(
-    "_adaptive_avg_pool2d",
-    *[](const Tensor &self, IntArrayRef output_size) {
-      return torch::adaptive_avg_pool2d(self, output_size);
-    })
-  .define_singleton_method(
-    "_adaptive_avg_pool2d_out",
-    *[](const Tensor &self, IntArrayRef output_size, Tensor &out) {
-      return torch::adaptive_avg_pool2d_out(out, self, output_size);
-    })
-  .define_singleton_method(
-    "_adaptive_avg_pool3d",
-    *[](const Tensor &self, IntArrayRef output_size) {
-      return torch::adaptive_avg_pool3d(self, output_size);
-    })
-  .define_singleton_method(
-    "_adaptive_avg_pool3d_out",
-    *[](const Tensor &self, IntArrayRef output_size, Tensor &out) {
-      return torch::adaptive_avg_pool3d_out(out, self, output_size);
-    })
-  .define_singleton_method(
-    "_adaptive_max_pool2d",
-    *[](const Tensor &self, IntArrayRef output_size) {
-      return wrap(torch::adaptive_max_pool2d(self, output_size));
-    })
-  .define_singleton_method(
-    "_adaptive_max_pool2d_out",
-    *[](const Tensor &self, IntArrayRef output_size, Tensor &out, Tensor &indices) {
-      return wrap(torch::adaptive_max_pool2d_out(out, indices, self, output_size));
-    })
-  .define_singleton_method(
-    "_adaptive_max_pool3d",
-    *[](const Tensor &self, IntArrayRef output_size) {
-      return wrap(torch::adaptive_max_pool3d(self, output_size));
-    })
-  .define_singleton_method(
-    "_adaptive_max_pool3d_out",
-    *[](const Tensor &self, IntArrayRef output_size, Tensor &out, Tensor &indices) {
-      return wrap(torch::adaptive_max_pool3d_out(out, indices, self, output_size));
-    })
-  .define_singleton_method(
-    "_avg_pool2d",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad) {
-      return torch::avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
-    })
-  .define_singleton_method(
-    "_avg_pool2d_divisor_override",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, int64_t divisor_override) {
-      return torch::avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
-    })
-  .define_singleton_method(
-    "_avg_pool3d",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad) {
-      return torch::avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
-    })
-  .define_singleton_method(
-    "_avg_pool3d_divisor_override",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, int64_t divisor_override) {
-      return torch::avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
-    })
-  .define_singleton_method(
-    "_binary_cross_entropy",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction) {
-      return torch::binary_cross_entropy(self, target, weight, reduction);
-    })
-  .define_singleton_method(
-    "_binary_cross_entropy_out",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, Tensor &out) {
-      return torch::binary_cross_entropy_out(out, self, target, weight, reduction);
-    })
-  .define_singleton_method(
-    "_col2im",
-    *[](const Tensor &self, IntArrayRef output_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
-      return torch::col2im(self, output_size, kernel_size, dilation, padding, stride);
-    })
-  .define_singleton_method(
-    "_col2im_out",
-    *[](const Tensor &self, IntArrayRef output_size, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride, Tensor &out) {
-      return torch::col2im_out(out, self, output_size, kernel_size, dilation, padding, stride);
-    })
-  .define_singleton_method(
-    "_elu",
-    *[](const Tensor &self, Scalar alpha, Scalar scale, Scalar input_scale) {
-      return torch::elu(self, alpha, scale, input_scale);
-    })
-  .define_singleton_method(
-    "_elu_",
-    *[](Tensor &self, Scalar alpha, Scalar scale, Scalar input_scale) {
-      return torch::elu_(self, alpha, scale, input_scale);
-    })
-  .define_singleton_method(
-    "_elu_out",
-    *[](const Tensor &self, Scalar alpha, Scalar scale, Scalar input_scale, Tensor &out) {
-      return torch::elu_out(out, self, alpha, scale, input_scale);
-    })
-  .define_singleton_method(
-    "_fractional_max_pool2d",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor &random_samples) {
-      return wrap(torch::fractional_max_pool2d(self, kernel_size, output_size, random_samples));
-    })
-  .define_singleton_method(
-    "_fractional_max_pool2d_output",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor &random_samples, Tensor &output, Tensor &indices) {
-      return wrap(torch::fractional_max_pool2d_out(output, indices, self, kernel_size, output_size, random_samples));
-    })
-  .define_singleton_method(
-    "_fractional_max_pool3d",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor &random_samples) {
-      return wrap(torch::fractional_max_pool3d(self, kernel_size, output_size, random_samples));
-    })
-  .define_singleton_method(
-    "_fractional_max_pool3d_output",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor &random_samples, Tensor &output, Tensor &indices) {
-      return wrap(torch::fractional_max_pool3d_out(output, indices, self, kernel_size, output_size, random_samples));
-    })
-  .define_singleton_method(
-    "_gelu",
-    *[](const Tensor &self) {
-      return torch::gelu(self);
-    })
-  .define_singleton_method(
-    "_glu",
-    *[](const Tensor &self, int64_t dim) {
-      return torch::glu(self, dim);
-    })
-  .define_singleton_method(
-    "_glu_out",
-    *[](const Tensor &self, int64_t dim, Tensor &out) {
-      return torch::glu_out(out, self, dim);
-    })
-  .define_singleton_method(
-    "_hardsigmoid",
-    *[](const Tensor &self) {
-      return torch::hardsigmoid(self);
-    })
-  .define_singleton_method(
-    "_hardsigmoid_",
-    *[](Tensor &self) {
-      return torch::hardsigmoid_(self);
-    })
-  .define_singleton_method(
-    "_hardsigmoid_out",
-    *[](const Tensor &self, Tensor &out) {
-      return torch::hardsigmoid_out(out, self);
-    })
-  .define_singleton_method(
-    "_hardtanh",
-    *[](const Tensor &self, Scalar min_val, Scalar max_val) {
-      return torch::hardtanh(self, min_val, max_val);
-    })
-  .define_singleton_method(
-    "_hardtanh_",
-    *[](Tensor &self, Scalar min_val, Scalar max_val) {
-      return torch::hardtanh_(self, min_val, max_val);
-    })
-  .define_singleton_method(
-    "_hardtanh_out",
-    *[](const Tensor &self, Scalar min_val, Scalar max_val, Tensor &out) {
-      return torch::hardtanh_out(out, self, min_val, max_val);
-    })
-  .define_singleton_method(
-    "_im2col",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride) {
-      return torch::im2col(self, kernel_size, dilation, padding, stride);
-    })
-  .define_singleton_method(
-    "_im2col_out",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef dilation, IntArrayRef padding, IntArrayRef stride, Tensor &out) {
-      return torch::im2col_out(out, self, kernel_size, dilation, padding, stride);
-    })
-  .define_singleton_method(
-    "_l1_loss",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction) {
-      return torch::l1_loss(self, target, reduction);
-    })
-  .define_singleton_method(
-    "_l1_loss_out",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction, Tensor &out) {
-      return torch::l1_loss_out(out, self, target, reduction);
-    })
-  .define_singleton_method(
-    "_leaky_relu",
-    *[](const Tensor &self, Scalar negative_slope) {
-      return torch::leaky_relu(self, negative_slope);
-    })
-  .define_singleton_method(
-    "_leaky_relu_",
-    *[](Tensor &self, Scalar negative_slope) {
-      return torch::leaky_relu_(self, negative_slope);
-    })
-  .define_singleton_method(
-    "_leaky_relu_out",
-    *[](const Tensor &self, Scalar negative_slope, Tensor &out) {
-      return torch::leaky_relu_out(out, self, negative_slope);
-    })
-  .define_singleton_method(
-    "_linear",
-    *[](const Tensor &input, const Tensor &weight, OptionalTensor bias) {
-      return torch::linear(input, weight, bias);
-    })
-  .define_singleton_method(
-    "_log_sigmoid",
-    *[](const Tensor &self) {
-      return torch::log_sigmoid(self);
-    })
-  .define_singleton_method(
-    "_log_sigmoid_forward",
-    *[](const Tensor &self) {
-      return wrap(torch::log_sigmoid_forward(self));
-    })
-  .define_singleton_method(
-    "_log_sigmoid_forward_output",
-    *[](const Tensor &self, Tensor &output, Tensor &buffer) {
-      return wrap(torch::log_sigmoid_forward_out(output, buffer, self));
-    })
-  .define_singleton_method(
-    "_log_sigmoid_out",
-    *[](const Tensor &self, Tensor &out) {
-      return torch::log_sigmoid_out(out, self);
-    })
-  .define_singleton_method(
-    "_max_pool2d_with_indices",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
-      return wrap(torch::max_pool2d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode));
-    })
-  .define_singleton_method(
-    "_max_pool2d_with_indices_out",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, Tensor &out, Tensor &indices) {
-      return wrap(torch::max_pool2d_with_indices_out(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode));
-    })
-  .define_singleton_method(
-    "_max_pool3d_with_indices",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
-      return wrap(torch::max_pool3d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode));
-    })
-  .define_singleton_method(
-    "_max_pool3d_with_indices_out",
-    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, Tensor &out, Tensor &indices) {
-      return wrap(torch::max_pool3d_with_indices_out(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode));
-    })
-  .define_singleton_method(
-    "_max_unpool2d",
-    *[](const Tensor &self, const Tensor &indices, IntArrayRef output_size) {
-      return torch::max_unpool2d(self, indices, output_size);
-    })
-  .define_singleton_method(
-    "_max_unpool2d_out",
-    *[](const Tensor &self, const Tensor &indices, IntArrayRef output_size, Tensor &out) {
-      return torch::max_unpool2d_out(out, self, indices, output_size);
-    })
-  .define_singleton_method(
-    "_max_unpool3d",
-    *[](const Tensor &self, const Tensor &indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding) {
-      return torch::max_unpool3d(self, indices, output_size, stride, padding);
-    })
-  .define_singleton_method(
-    "_max_unpool3d_out",
-    *[](const Tensor &self, const Tensor &indices, IntArrayRef output_size, IntArrayRef stride, IntArrayRef padding, Tensor &out) {
-      return torch::max_unpool3d_out(out, self, indices, output_size, stride, padding);
-    })
-  .define_singleton_method(
-    "_mkldnn_linear",
-    *[](const Tensor &input, const Tensor &weight, OptionalTensor bias) {
-      return torch::mkldnn_linear(input, weight, bias);
-    })
-  .define_singleton_method(
-    "_mkldnn_reorder_conv2d_weight",
-    *[](const Tensor &self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups) {
-      return torch::mkldnn_reorder_conv2d_weight(self, padding, stride, dilation, groups);
-    })
-  .define_singleton_method(
-    "_mse_loss",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction) {
-      return torch::mse_loss(self, target, reduction);
-    })
-  .define_singleton_method(
-    "_mse_loss_out",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction, Tensor &out) {
-      return torch::mse_loss_out(out, self, target, reduction);
-    })
-  .define_singleton_method(
-    "_multi_margin_loss",
-    *[](const Tensor &self, const Tensor &target, Scalar p, Scalar margin, OptionalTensor weight, MyReduction reduction) {
-      return torch::multi_margin_loss(self, target, p, margin, weight, reduction);
-    })
-  .define_singleton_method(
-    "_multi_margin_loss_out",
-    *[](const Tensor &self, const Tensor &target, Scalar p, Scalar margin, OptionalTensor weight, MyReduction reduction, Tensor &out) {
-      return torch::multi_margin_loss_out(out, self, target, p, margin, weight, reduction);
-    })
-  .define_singleton_method(
-    "_multilabel_margin_loss",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction) {
-      return torch::multilabel_margin_loss(self, target, reduction);
-    })
-  .define_singleton_method(
-    "_multilabel_margin_loss_forward",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction) {
-      return wrap(torch::multilabel_margin_loss_forward(self, target, reduction));
-    })
-  .define_singleton_method(
-    "_multilabel_margin_loss_forward_output",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction, Tensor &output, Tensor &is_target) {
-      return wrap(torch::multilabel_margin_loss_forward_out(output, is_target, self, target, reduction));
-    })
-  .define_singleton_method(
-    "_multilabel_margin_loss_out",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction, Tensor &out) {
-      return torch::multilabel_margin_loss_out(out, self, target, reduction);
-    })
-  .define_singleton_method(
-    "_nll_loss",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index) {
-      return torch::nll_loss(self, target, weight, reduction, ignore_index);
-    })
-  .define_singleton_method(
-    "_nll_loss2d",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index) {
-      return torch::nll_loss2d(self, target, weight, reduction, ignore_index);
-    })
-  .define_singleton_method(
-    "_nll_loss2d_forward",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index) {
-      return wrap(torch::nll_loss2d_forward(self, target, weight, reduction, ignore_index));
-    })
-  .define_singleton_method(
-    "_nll_loss2d_forward_output",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index, Tensor &output, Tensor &total_weight) {
-      return wrap(torch::nll_loss2d_forward_out(output, total_weight, self, target, weight, reduction, ignore_index));
-    })
-  .define_singleton_method(
-    "_nll_loss2d_out",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index, Tensor &out) {
-      return torch::nll_loss2d_out(out, self, target, weight, reduction, ignore_index);
-    })
-  .define_singleton_method(
-    "_nll_loss_forward",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index) {
-      return wrap(torch::nll_loss_forward(self, target, weight, reduction, ignore_index));
-    })
-  .define_singleton_method(
-    "_nll_loss_forward_output",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index, Tensor &output, Tensor &total_weight) {
-      return wrap(torch::nll_loss_forward_out(output, total_weight, self, target, weight, reduction, ignore_index));
-    })
-  .define_singleton_method(
-    "_nll_loss_out",
-    *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index, Tensor &out) {
-      return torch::nll_loss_out(out, self, target, weight, reduction, ignore_index);
-    })
-  .define_singleton_method(
-    "_one_hot",
-    *[](const Tensor &self, int64_t num_classes) {
-      return torch::one_hot(self, num_classes);
-    })
-  .define_singleton_method(
-    "_reflection_pad1d",
-    *[](const Tensor &self, IntArrayRef padding) {
-      return torch::reflection_pad1d(self, padding);
-    })
-  .define_singleton_method(
-    "_reflection_pad1d_out",
-    *[](const Tensor &self, IntArrayRef padding, Tensor &out) {
-      return torch::reflection_pad1d_out(out, self, padding);
-    })
-  .define_singleton_method(
-    "_reflection_pad2d",
-    *[](const Tensor &self, IntArrayRef padding) {
-      return torch::reflection_pad2d(self, padding);
-    })
-  .define_singleton_method(
-    "_reflection_pad2d_out",
-    *[](const Tensor &self, IntArrayRef padding, Tensor &out) {
-      return torch::reflection_pad2d_out(out, self, padding);
-    })
-  .define_singleton_method(
-    "_replication_pad1d",
-    *[](const Tensor &self, IntArrayRef padding) {
-      return torch::replication_pad1d(self, padding);
-    })
-  .define_singleton_method(
-    "_replication_pad1d_out",
-    *[](const Tensor &self, IntArrayRef padding, Tensor &out) {
-      return torch::replication_pad1d_out(out, self, padding);
-    })
-  .define_singleton_method(
-    "_replication_pad2d",
-    *[](const Tensor &self, IntArrayRef padding) {
-      return torch::replication_pad2d(self, padding);
-    })
-  .define_singleton_method(
-    "_replication_pad2d_out",
-    *[](const Tensor &self, IntArrayRef padding, Tensor &out) {
-      return torch::replication_pad2d_out(out, self, padding);
-    })
-  .define_singleton_method(
-    "_replication_pad3d",
-    *[](const Tensor &self, IntArrayRef padding) {
-      return torch::replication_pad3d(self, padding);
-    })
-  .define_singleton_method(
-    "_replication_pad3d_out",
-    *[](const Tensor &self, IntArrayRef padding, Tensor &out) {
-      return torch::replication_pad3d_out(out, self, padding);
-    })
-  .define_singleton_method(
-    "_rrelu_with_noise",
-    *[](const Tensor &self, const Tensor &noise, Scalar lower, Scalar upper, bool training) {
-      return torch::rrelu_with_noise(self, noise, lower, upper, training);
-    })
-  .define_singleton_method(
-    "_rrelu_with_noise_",
-    *[](Tensor &self, const Tensor &noise, Scalar lower, Scalar upper, bool training) {
-      return torch::rrelu_with_noise_(self, noise, lower, upper, training);
-    })
-  .define_singleton_method(
-    "_rrelu_with_noise_out",
-    *[](const Tensor &self, const Tensor &noise, Scalar lower, Scalar upper, bool training, Tensor &out) {
-      return torch::rrelu_with_noise_out(out, self, noise, lower, upper, training);
-    })
-  .define_singleton_method(
-    "_slow_conv3d",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding) {
-      return torch::slow_conv3d(self, weight, kernel_size, bias, stride, padding);
-    })
-  .define_singleton_method(
-    "_slow_conv3d_forward",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding) {
-      return wrap(torch::slow_conv3d_forward(self, weight, kernel_size, bias, stride, padding));
-    })
-  .define_singleton_method(
-    "_slow_conv3d_forward_output",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, Tensor &output, Tensor &finput, Tensor &fgrad_input) {
-      return wrap(torch::slow_conv3d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding));
-    })
-  .define_singleton_method(
-    "_slow_conv3d_out",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, Tensor &out) {
-      return torch::slow_conv3d_out(out, self, weight, kernel_size, bias, stride, padding);
-    })
-  .define_singleton_method(
-    "_slow_conv_dilated2d",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
-      return torch::slow_conv_dilated2d(self, weight, kernel_size, bias, stride, padding, dilation);
-    })
-  .define_singleton_method(
-    "_slow_conv_dilated3d",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
-      return torch::slow_conv_dilated3d(self, weight, kernel_size, bias, stride, padding, dilation);
-    })
-  .define_singleton_method(
-    "_slow_conv_transpose2d",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation) {
-      return torch::slow_conv_transpose2d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
-    })
-  .define_singleton_method(
-    "_slow_conv_transpose2d_out",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, Tensor &out) {
-      return torch::slow_conv_transpose2d_out(out, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
-    })
-  .define_singleton_method(
-    "_slow_conv_transpose3d",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation) {
-      return torch::slow_conv_transpose3d(self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
-    })
-  .define_singleton_method(
-    "_slow_conv_transpose3d_out",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef output_padding, IntArrayRef dilation, Tensor &out) {
-      return torch::slow_conv_transpose3d_out(out, self, weight, kernel_size, bias, stride, padding, output_padding, dilation);
-    })
-  .define_singleton_method(
-    "_smooth_l1_loss",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction) {
-      return torch::smooth_l1_loss(self, target, reduction);
-    })
-  .define_singleton_method(
-    "_smooth_l1_loss_out",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction, Tensor &out) {
-      return torch::smooth_l1_loss_out(out, self, target, reduction);
-    })
-  .define_singleton_method(
-    "_soft_margin_loss",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction) {
-      return torch::soft_margin_loss(self, target, reduction);
-    })
-  .define_singleton_method(
-    "_soft_margin_loss_out",
-    *[](const Tensor &self, const Tensor &target, MyReduction reduction, Tensor &out) {
-      return torch::soft_margin_loss_out(out, self, target, reduction);
-    })
-  .define_singleton_method(
-    "_softplus",
-    *[](const Tensor &self, Scalar beta, Scalar threshold) {
-      return torch::softplus(self, beta, threshold);
-    })
-  .define_singleton_method(
-    "_softplus_out",
-    *[](const Tensor &self, Scalar beta, Scalar threshold, Tensor &out) {
-      return torch::softplus_out(out, self, beta, threshold);
-    })
-  .define_singleton_method(
-    "_softshrink",
-    *[](const Tensor &self, Scalar lambd) {
-      return torch::softshrink(self, lambd);
-    })
-  .define_singleton_method(
-    "_softshrink_out",
-    *[](const Tensor &self, Scalar lambd, Tensor &out) {
-      return torch::softshrink_out(out, self, lambd);
-    })
-  .define_singleton_method(
-    "_thnn_conv2d",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding) {
-      return torch::thnn_conv2d(self, weight, kernel_size, bias, stride, padding);
-    })
-  .define_singleton_method(
-    "_thnn_conv2d_forward",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding) {
-      return wrap(torch::thnn_conv2d_forward(self, weight, kernel_size, bias, stride, padding));
-    })
-  .define_singleton_method(
-    "_thnn_conv2d_forward_output",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, Tensor &output, Tensor &finput, Tensor &fgrad_input) {
-      return wrap(torch::thnn_conv2d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding));
-    })
-  .define_singleton_method(
-    "_thnn_conv2d_out",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, Tensor &out) {
-      return torch::thnn_conv2d_out(out, self, weight, kernel_size, bias, stride, padding);
-    })
-  .define_singleton_method(
-    "_thnn_conv_depthwise2d",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
-      return torch::thnn_conv_depthwise2d(self, weight, kernel_size, bias, stride, padding, dilation);
-    })
-  .define_singleton_method(
-    "_thnn_conv_depthwise2d_forward",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation) {
-      return torch::thnn_conv_depthwise2d_forward(self, weight, kernel_size, bias, stride, padding, dilation);
-    })
-  .define_singleton_method(
-    "_thnn_conv_depthwise2d_forward_out",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, Tensor &out) {
-      return torch::thnn_conv_depthwise2d_forward_out(out, self, weight, kernel_size, bias, stride, padding, dilation);
-    })
-  .define_singleton_method(
-    "_thnn_conv_depthwise2d_out",
-    *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, Tensor &out) {
-      return torch::thnn_conv_depthwise2d_out(out, self, weight, kernel_size, bias, stride, padding, dilation);
-    });
-}