torch-rb 0.1.1 → 0.1.6

data/ext/torch/nn_functions.hpp

@@ -0,0 +1,6 @@
+// generated by rake generate:functions
+// do not edit by hand
+
+#pragma once
+
+void add_nn_functions(Module m);

data/ext/torch/templates.cpp

@@ -0,0 +1,55 @@
+#include <torch/torch.h>
+#include <rice/Object.hpp>
+#include "templates.hpp"
+
+Object wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
+  Array a;
+  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
+  return Object(a);
+}
+
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
+  Array a;
+  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<2>(x)));
+  return Object(a);
+}
+
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
+  Array a;
+  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<2>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<3>(x)));
+  return Object(a);
+}
+
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
+  Array a;
+  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<2>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<3>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<4>(x)));
+  return Object(a);
+}
+
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x) {
+  Array a;
+  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<2>(x)));
+  a.push(to_ruby<int64_t>(std::get<3>(x)));
+  return Object(a);
+}
+
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
+  Array a;
+  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
+  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
+  a.push(to_ruby<double>(std::get<2>(x)));
+  a.push(to_ruby<int64_t>(std::get<3>(x)));
+  return Object(a);
+}

data/ext/torch/templates.hpp

@@ -0,0 +1,298 @@
+#pragma once
+
+#include <rice/Array.hpp>
+#include <rice/Object.hpp>
+
+using namespace Rice;
+
+template<>
+inline
+long long from_ruby<long long>(Object x)
+{
+  return NUM2LL(x);
+}
+
+template<>
+inline
+Object to_ruby<long long>(long long const & x)
+{
+  return LL2NUM(x);
+}
+
+template<>
+inline
+unsigned long long from_ruby<unsigned long long>(Object x)
+{
+  return NUM2ULL(x);
+}
+
+template<>
+inline
+Object to_ruby<unsigned long long>(unsigned long long const & x)
+{
+  return ULL2NUM(x);
+}
+
+template<>
+inline
+short from_ruby<short>(Object x)
+{
+  return NUM2SHORT(x);
+}
+
+template<>
+inline
+Object to_ruby<short>(short const & x)
+{
+  return INT2NUM(x);
+}
+
+template<>
+inline
+unsigned short from_ruby<unsigned short>(Object x)
+{
+  return NUM2USHORT(x);
+}
+
+template<>
+inline
+Object to_ruby<unsigned short>(unsigned short const & x)
+{
+  return UINT2NUM(x);
+}
+
+// need to wrap torch::IntArrayRef() since
+// it doesn't own underlying data
+class IntArrayRef {
+  std::vector<int64_t> vec;
+  public:
+    IntArrayRef(Object o) {
+      Array a = Array(o);
+      for (size_t i = 0; i < a.size(); i++) {
+        vec.push_back(from_ruby<int64_t>(a[i]));
+      }
+    }
+    operator torch::IntArrayRef() {
+      return torch::IntArrayRef(vec);
+    }
+};
+
+template<>
+inline
+IntArrayRef from_ruby<IntArrayRef>(Object x)
+{
+  return IntArrayRef(x);
+}
+
+// for now
+class Scalar {
+  torch::Scalar value;
+  public:
+    Scalar(Object o) {
+      // TODO cast based on Ruby type
+      if (o.rb_type() == T_FIXNUM) {
+        value = torch::Scalar(from_ruby<int64_t>(o));
+      } else {
+        value = torch::Scalar(from_ruby<float>(o));
+      }
+    }
+    operator torch::Scalar() {
+      return value;
+    }
+};
+
+template<>
+inline
+Scalar from_ruby<Scalar>(Object x)
+{
+  return Scalar(x);
+}
+
+class TensorList {
+  std::vector<torch::Tensor> vec;
+  public:
+    TensorList(Object o) {
+      Array a = Array(o);
+      for (size_t i = 0; i < a.size(); i++) {
+        vec.push_back(from_ruby<torch::Tensor>(a[i]));
+      }
+    }
+    operator torch::TensorList() {
+      return torch::TensorList(vec);
+    }
+};
+
+template<>
+inline
+TensorList from_ruby<TensorList>(Object x)
+{
+  return TensorList(x);
+}
+
+class FanModeType {
+  std::string s;
+  public:
+    FanModeType(Object o) {
+      s = String(o).str();
+    }
+    // TODO switch NonlinearityType after LibTorch 1.4 release
+    operator torch::nn::init::FanMode() {
+      if (s == "fan_in") {
+        return torch::nn::init::FanMode::FanIn;
+      } else if (s == "fan_out") {
+        return torch::nn::init::FanMode::FanOut;
+      } else {
+        throw std::runtime_error("Unsupported nonlinearity type: " + s);
+      }
+    }
+};
+
+template<>
+inline
+FanModeType from_ruby<FanModeType>(Object x)
+{
+  return FanModeType(x);
+}
+
+class NonlinearityType {
+  std::string s;
+  public:
+    NonlinearityType(Object o) {
+      s = String(o).str();
+    }
+    // TODO switch NonlinearityType after LibTorch 1.4 release
+    operator torch::nn::init::Nonlinearity() {
+      if (s == "linear") {
+        return torch::nn::init::Nonlinearity::Linear;
+      } else if (s == "conv1d") {
+        return torch::nn::init::Nonlinearity::Conv1D;
+      } else if (s == "conv2d") {
+        return torch::nn::init::Nonlinearity::Conv2D;
+      } else if (s == "conv3d") {
+        return torch::nn::init::Nonlinearity::Conv3D;
+      } else if (s == "conv_transpose1d") {
+        return torch::nn::init::Nonlinearity::ConvTranspose1D;
+      } else if (s == "conv_transpose2d") {
+        return torch::nn::init::Nonlinearity::ConvTranspose2D;
+      } else if (s == "conv_transpose3d") {
+        return torch::nn::init::Nonlinearity::ConvTranspose3D;
+      } else if (s == "sigmoid") {
+        return torch::nn::init::Nonlinearity::Sigmoid;
+      } else if (s == "tanh") {
+        return torch::nn::init::Nonlinearity::Tanh;
+      } else if (s == "relu") {
+        return torch::nn::init::Nonlinearity::ReLU;
+      } else if (s == "leaky_relu") {
+        return torch::nn::init::Nonlinearity::LeakyReLU;
+      } else {
+        throw std::runtime_error("Unsupported nonlinearity type: " + s);
+      }
+    }
+};
+
+template<>
+inline
+NonlinearityType from_ruby<NonlinearityType>(Object x)
+{
+  return NonlinearityType(x);
+}
+
+class MyReduction {
+  Object value;
+  public:
+    MyReduction(Object o) {
+      value = o;
+    }
+    operator int64_t() {
+      if (value.is_nil()) {
+        return Reduction::None;
+      }
+
+      std::string s = String(value).str();
+      if (s == "mean") {
+        return Reduction::Mean;
+      } else if (s == "sum") {
+        return Reduction::Sum;
+      } else {
+        throw std::runtime_error("Unsupported reduction: " + s);
+      }
+    }
+};
+
+template<>
+inline
+MyReduction from_ruby<MyReduction>(Object x)
+{
+  return MyReduction(x);
+}
+
+typedef torch::Tensor Tensor;
+
+class OptionalTensor {
+  Object value;
+  public:
+    OptionalTensor(Object o) {
+      value = o;
+    }
+    operator torch::Tensor() {
+      if (value.is_nil()) {
+        return {};
+      }
+      return from_ruby<torch::Tensor>(value);
+    }
+};
+
+template<>
+inline
+OptionalTensor from_ruby<OptionalTensor>(Object x)
+{
+  return OptionalTensor(x);
+}
+
+class ScalarType {
+  Object value;
+  public:
+    ScalarType(Object o) {
+      value = o;
+    }
+    operator at::ScalarType() {
+      throw std::runtime_error("ScalarType arguments not implemented yet");
+    }
+};
+
+template<>
+inline
+ScalarType from_ruby<ScalarType>(Object x)
+{
+  return ScalarType(x);
+}
+
+class OptionalScalarType {
+  Object value;
+  public:
+    OptionalScalarType(Object o) {
+      value = o;
+    }
+    operator c10::optional<at::ScalarType>() {
+      if (value.is_nil()) {
+        return c10::nullopt;
+      }
+      return ScalarType(value);
+    }
+};
+
+template<>
+inline
+OptionalScalarType from_ruby<OptionalScalarType>(Object x)
+{
+  return OptionalScalarType(x);
+}
+
+typedef torch::Device Device;
+
+Object wrap(std::tuple<torch::Tensor, torch::Tensor> x);
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x);
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x);
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x);
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x);
+Object wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x);

data/ext/torch/tensor_functions.cpp

@@ -0,0 +1,1920 @@
+// generated by rake generate:functions
+// do not edit by hand
+
+#include <torch/torch.h>
+#include <rice/Module.hpp>
+#include "templates.hpp"
+
+void add_tensor_functions(Module m) {
+  m
+  .define_method(
+    "_abs",
+    *[](const Tensor &self) {
+      return self.abs();
+    })
+  .define_method(
+    "_abs_",
+    *[](Tensor &self) {
+      return self.abs_();
+    })
+  .define_method(
+    "_acos",
+    *[](const Tensor &self) {
+      return self.acos();
+    })
+  .define_method(
+    "_acos_",
+    *[](Tensor &self) {
+      return self.acos_();
+    })
+  .define_method(
+    "_add__scalar",
+    *[](Tensor &self, Scalar other, Scalar alpha) {
+      return self.add_(other, alpha);
+    })
+  .define_method(
+    "_add__tensor",
+    *[](Tensor &self, const Tensor &other, Scalar alpha) {
+      return self.add_(other, alpha);
+    })
+  .define_method(
+    "_add_scalar",
+    *[](const Tensor &self, Scalar other, Scalar alpha) {
+      return self.add(other, alpha);
+    })
+  .define_method(
+    "_add_tensor",
+    *[](const Tensor &self, const Tensor &other, Scalar alpha) {
+      return self.add(other, alpha);
+    })
+  .define_method(
+    "_addbmm",
+    *[](const Tensor &self, const Tensor &batch1, const Tensor &batch2, Scalar beta, Scalar alpha) {
+      return self.addbmm(batch1, batch2, beta, alpha);
+    })
+  .define_method(
+    "_addbmm_",
+    *[](Tensor &self, const Tensor &batch1, const Tensor &batch2, Scalar beta, Scalar alpha) {
+      return self.addbmm_(batch1, batch2, beta, alpha);
+    })
+  .define_method(
+    "_addcdiv",
+    *[](const Tensor &self, const Tensor &tensor1, const Tensor &tensor2, Scalar value) {
+      return self.addcdiv(tensor1, tensor2, value);
+    })
+  .define_method(
+    "_addcdiv_",
+    *[](Tensor &self, const Tensor &tensor1, const Tensor &tensor2, Scalar value) {
+      return self.addcdiv_(tensor1, tensor2, value);
+    })
+  .define_method(
+    "_addcmul",
+    *[](const Tensor &self, const Tensor &tensor1, const Tensor &tensor2, Scalar value) {
+      return self.addcmul(tensor1, tensor2, value);
+    })
+  .define_method(
+    "_addcmul_",
+    *[](Tensor &self, const Tensor &tensor1, const Tensor &tensor2, Scalar value) {
+      return self.addcmul_(tensor1, tensor2, value);
+    })
+  .define_method(
+    "_addmm",
+    *[](const Tensor &self, const Tensor &mat1, const Tensor &mat2, Scalar beta, Scalar alpha) {
+      return self.addmm(mat1, mat2, beta, alpha);
+    })
+  .define_method(
+    "_addmm_",
+    *[](Tensor &self, const Tensor &mat1, const Tensor &mat2, Scalar beta, Scalar alpha) {
+      return self.addmm_(mat1, mat2, beta, alpha);
+    })
+  .define_method(
+    "_addmv",
+    *[](const Tensor &self, const Tensor &mat, const Tensor &vec, Scalar beta, Scalar alpha) {
+      return self.addmv(mat, vec, beta, alpha);
+    })
+  .define_method(
+    "_addmv_",
+    *[](Tensor &self, const Tensor &mat, const Tensor &vec, Scalar beta, Scalar alpha) {
+      return self.addmv_(mat, vec, beta, alpha);
+    })
+  .define_method(
+    "_addr",
+    *[](const Tensor &self, const Tensor &vec1, const Tensor &vec2, Scalar beta, Scalar alpha) {
+      return self.addr(vec1, vec2, beta, alpha);
+    })
+  .define_method(
+    "_addr_",
+    *[](Tensor &self, const Tensor &vec1, const Tensor &vec2, Scalar beta, Scalar alpha) {
+      return self.addr_(vec1, vec2, beta, alpha);
+    })
+  .define_method(
+    "_alias",
+    *[](Tensor &self) {
+      return self.alias();
+    })
+  .define_method(
+    "_align_as",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.align_as(other);
+    })
+  .define_method(
+    "_all",
+    *[](const Tensor &self) {
+      return self.all();
+    })
+  .define_method(
+    "_all_dim",
+    *[](const Tensor &self, int64_t dim, bool keepdim) {
+      return self.all(dim, keepdim);
+    })
+  .define_method(
+    "_allclose",
+    *[](const Tensor &self, const Tensor &other, double rtol, double atol, bool equal_nan) {
+      return self.allclose(other, rtol, atol, equal_nan);
+    })
+  .define_method(
+    "_any",
+    *[](const Tensor &self) {
+      return self.any();
+    })
+  .define_method(
+    "_any_dim",
+    *[](const Tensor &self, int64_t dim, bool keepdim) {
+      return self.any(dim, keepdim);
+    })
+  .define_method(
+    "_argmax",
+    *[](const Tensor &self) {
+      return self.argmax();
+    })
+  .define_method(
+    "_argmax_dim",
+    *[](const Tensor &self, int64_t dim, bool keepdim) {
+      return self.argmax(dim, keepdim);
+    })
+  .define_method(
+    "_argmin",
+    *[](const Tensor &self) {
+      return self.argmin();
+    })
+  .define_method(
+    "_argmin_dim",
+    *[](const Tensor &self, int64_t dim, bool keepdim) {
+      return self.argmin(dim, keepdim);
+    })
+  .define_method(
+    "_argsort",
+    *[](const Tensor &self, int64_t dim, bool descending) {
+      return self.argsort(dim, descending);
+    })
+  .define_method(
+    "_as_strided",
+    *[](Tensor &self, IntArrayRef size, IntArrayRef stride) {
+      return self.as_strided(size, stride);
+    })
+  .define_method(
+    "_as_strided_",
+    *[](Tensor &self, IntArrayRef size, IntArrayRef stride) {
+      return self.as_strided_(size, stride);
+    })
+  .define_method(
+    "_as_strided__storage_offset",
+    *[](Tensor &self, IntArrayRef size, IntArrayRef stride, int64_t storage_offset) {
+      return self.as_strided_(size, stride, storage_offset);
+    })
+  .define_method(
+    "_as_strided_storage_offset",
+    *[](Tensor &self, IntArrayRef size, IntArrayRef stride, int64_t storage_offset) {
+      return self.as_strided(size, stride, storage_offset);
+    })
+  .define_method(
+    "_asin",
+    *[](const Tensor &self) {
+      return self.asin();
+    })
+  .define_method(
+    "_asin_",
+    *[](Tensor &self) {
+      return self.asin_();
+    })
+  .define_method(
+    "_atan",
+    *[](const Tensor &self) {
+      return self.atan();
+    })
+  .define_method(
+    "_atan2",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.atan2(other);
+    })
+  .define_method(
+    "_atan2_",
+    *[](Tensor &self, const Tensor &other) {
+      return self.atan2_(other);
+    })
+  .define_method(
+    "_atan_",
+    *[](Tensor &self) {
+      return self.atan_();
+    })
+  .define_method(
+    "_backward",
+    *[](const Tensor &self, OptionalTensor gradient, bool keep_graph, bool create_graph) {
+      return self.backward(gradient, keep_graph, create_graph);
+    })
+  .define_method(
+    "_baddbmm",
+    *[](const Tensor &self, const Tensor &batch1, const Tensor &batch2, Scalar beta, Scalar alpha) {
+      return self.baddbmm(batch1, batch2, beta, alpha);
+    })
+  .define_method(
+    "_baddbmm_",
+    *[](Tensor &self, const Tensor &batch1, const Tensor &batch2, Scalar beta, Scalar alpha) {
+      return self.baddbmm_(batch1, batch2, beta, alpha);
+    })
+  .define_method(
+    "_bernoulli",
+    *[](const Tensor &self) {
+      return self.bernoulli();
+    })
+  .define_method(
+    "_bernoulli__float",
+    *[](Tensor &self, double p) {
+      return self.bernoulli_(p);
+    })
+  .define_method(
+    "_bernoulli__tensor",
+    *[](Tensor &self, const Tensor &p) {
+      return self.bernoulli_(p);
+    })
+  .define_method(
+    "_bernoulli_p",
+    *[](const Tensor &self, double p) {
+      return self.bernoulli(p);
+    })
+  .define_method(
+    "_bincount",
+    *[](const Tensor &self, OptionalTensor weights, int64_t minlength) {
+      return self.bincount(weights, minlength);
+    })
+  .define_method(
+    "_bitwise_not",
+    *[](const Tensor &self) {
+      return self.bitwise_not();
+    })
+  .define_method(
+    "_bitwise_not_",
+    *[](Tensor &self) {
+      return self.bitwise_not_();
+    })
+  .define_method(
+    "_bmm",
+    *[](const Tensor &self, const Tensor &mat2) {
+      return self.bmm(mat2);
+    })
+  .define_method(
+    "_cauchy_",
+    *[](Tensor &self, double median, double sigma) {
+      return self.cauchy_(median, sigma);
+    })
+  .define_method(
+    "_ceil",
+    *[](const Tensor &self) {
+      return self.ceil();
+    })
+  .define_method(
+    "_ceil_",
+    *[](Tensor &self) {
+      return self.ceil_();
+    })
+  .define_method(
+    "_cholesky",
+    *[](const Tensor &self, bool upper) {
+      return self.cholesky(upper);
+    })
+  .define_method(
+    "_cholesky_inverse",
+    *[](const Tensor &self, bool upper) {
+      return self.cholesky_inverse(upper);
+    })
+  .define_method(
+    "_cholesky_solve",
+    *[](const Tensor &self, const Tensor &input2, bool upper) {
+      return self.cholesky_solve(input2, upper);
+    })
+  .define_method(
+    "_chunk",
+    *[](Tensor &self, int64_t chunks, int64_t dim) {
+      return self.chunk(chunks, dim);
+    })
+  .define_method(
+    "_clamp_max",
+    *[](const Tensor &self, Scalar max) {
+      return self.clamp_max(max);
+    })
+  .define_method(
+    "_clamp_max_",
+    *[](Tensor &self, Scalar max) {
+      return self.clamp_max_(max);
+    })
+  .define_method(
+    "_clamp_min",
+    *[](const Tensor &self, Scalar min) {
+      return self.clamp_min(min);
+    })
+  .define_method(
+    "_clamp_min_",
+    *[](Tensor &self, Scalar min) {
+      return self.clamp_min_(min);
+    })
+  .define_method(
+    "_clone",
+    *[](const Tensor &self) {
+      return self.clone();
+    })
+  .define_method(
+    "_coalesce",
+    *[](const Tensor &self) {
+      return self.coalesce();
+    })
+  .define_method(
+    "_copy_",
+    *[](Tensor &self, const Tensor &src, bool non_blocking) {
+      return self.copy_(src, non_blocking);
+    })
+  .define_method(
+    "_cos",
+    *[](const Tensor &self) {
+      return self.cos();
+    })
+  .define_method(
+    "_cos_",
+    *[](Tensor &self) {
+      return self.cos_();
+    })
+  .define_method(
+    "_cosh",
+    *[](const Tensor &self) {
+      return self.cosh();
+    })
+  .define_method(
+    "_cosh_",
+    *[](Tensor &self) {
+      return self.cosh_();
+    })
+  .define_method(
+    "_cumprod",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype) {
+      return self.cumprod(dim, dtype);
+    })
+  .define_method(
+    "_cumsum",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype) {
+      return self.cumsum(dim, dtype);
+    })
+  .define_method(
+    "_data",
+    *[](const Tensor &self) {
+      return self.data();
+    })
+  .define_method(
+    "_dense_dim",
+    *[](const Tensor &self) {
+      return self.dense_dim();
+    })
+  .define_method(
+    "_dequantize",
+    *[](const Tensor &self) {
+      return self.dequantize();
+    })
+  .define_method(
+    "_det",
+    *[](const Tensor &self) {
+      return self.det();
+    })
+  .define_method(
+    "_detach",
+    *[](const Tensor &self) {
+      return self.detach();
+    })
+  .define_method(
+    "_detach_",
+    *[](Tensor &self) {
+      return self.detach_();
+    })
+  .define_method(
+    "_diag",
+    *[](const Tensor &self, int64_t diagonal) {
+      return self.diag(diagonal);
+    })
+  .define_method(
+    "_diag_embed",
+    *[](const Tensor &self, int64_t offset, int64_t dim1, int64_t dim2) {
+      return self.diag_embed(offset, dim1, dim2);
+    })
+  .define_method(
+    "_diagflat",
+    *[](const Tensor &self, int64_t offset) {
+      return self.diagflat(offset);
+    })
+  .define_method(
+    "_diagonal",
+    *[](Tensor &self, int64_t offset, int64_t dim1, int64_t dim2) {
+      return self.diagonal(offset, dim1, dim2);
+    })
+  .define_method(
+    "_digamma",
+    *[](const Tensor &self) {
+      return self.digamma();
+    })
+  .define_method(
+    "_digamma_",
+    *[](Tensor &self) {
+      return self.digamma_();
+    })
+  .define_method(
+    "_dist",
+    *[](const Tensor &self, const Tensor &other, Scalar p) {
+      return self.dist(other, p);
+    })
+  .define_method(
+    "_div__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.div_(other);
+    })
+  .define_method(
+    "_div__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.div_(other);
+    })
+  .define_method(
+    "_div_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.div(other);
+    })
+  .define_method(
+    "_div_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.div(other);
+    })
+  .define_method(
+    "_dot",
+    *[](const Tensor &self, const Tensor &tensor) {
+      return self.dot(tensor);
+    })
+  .define_method(
+    "_eig",
+    *[](const Tensor &self, bool eigenvectors) {
+      return wrap(self.eig(eigenvectors));
+    })
+  .define_method(
+    "_eq__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.eq_(other);
+    })
+  .define_method(
+    "_eq__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.eq_(other);
+    })
+  .define_method(
+    "_eq_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.eq(other);
+    })
+  .define_method(
+    "_eq_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.eq(other);
+    })
+  .define_method(
+    "_equal",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.equal(other);
+    })
+  .define_method(
+    "_erf",
+    *[](const Tensor &self) {
+      return self.erf();
+    })
+  .define_method(
+    "_erf_",
+    *[](Tensor &self) {
+      return self.erf_();
+    })
+  .define_method(
+    "_erfc",
+    *[](const Tensor &self) {
+      return self.erfc();
+    })
+  .define_method(
+    "_erfc_",
+    *[](Tensor &self) {
+      return self.erfc_();
+    })
+  .define_method(
+    "_erfinv",
+    *[](const Tensor &self) {
+      return self.erfinv();
+    })
+  .define_method(
+    "_erfinv_",
+    *[](Tensor &self) {
+      return self.erfinv_();
+    })
+  .define_method(
+    "_exp",
+    *[](const Tensor &self) {
+      return self.exp();
+    })
+  .define_method(
+    "_exp_",
+    *[](Tensor &self) {
+      return self.exp_();
+    })
+  .define_method(
+    "_expand",
+    *[](Tensor &self, IntArrayRef size, bool implicit) {
+      return self.expand(size, implicit);
+    })
+  .define_method(
+    "_expand_as",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.expand_as(other);
+    })
+  .define_method(
+    "_expm1",
+    *[](const Tensor &self) {
+      return self.expm1();
+    })
+  .define_method(
+    "_expm1_",
+    *[](Tensor &self) {
+      return self.expm1_();
+    })
+  .define_method(
+    "_exponential_",
+    *[](Tensor &self, double lambd) {
+      return self.exponential_(lambd);
+    })
+  .define_method(
+    "_fft",
+    *[](const Tensor &self, int64_t signal_ndim, bool normalized) {
+      return self.fft(signal_ndim, normalized);
+    })
+  .define_method(
+    "_fill__scalar",
+    *[](Tensor &self, Scalar value) {
+      return self.fill_(value);
+    })
+  .define_method(
+    "_fill__tensor",
+    *[](Tensor &self, const Tensor &value) {
+      return self.fill_(value);
+    })
+  .define_method(
+    "_fill_diagonal_",
+    *[](Tensor &self, Scalar fill_value, bool wrap) {
+      return self.fill_diagonal_(fill_value, wrap);
+    })
+  .define_method(
+    "_flatten_using_ints",
+    *[](const Tensor &self, int64_t start_dim, int64_t end_dim) {
+      return self.flatten(start_dim, end_dim);
+    })
+  .define_method(
+    "_flip",
+    *[](const Tensor &self, IntArrayRef dims) {
+      return self.flip(dims);
+    })
+  .define_method(
+    "_floor",
+    *[](const Tensor &self) {
+      return self.floor();
+    })
+  .define_method(
+    "_floor_",
+    *[](Tensor &self) {
+      return self.floor_();
+    })
+  .define_method(
+    "_fmod__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.fmod_(other);
+    })
+  .define_method(
+    "_fmod__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.fmod_(other);
+    })
+  .define_method(
+    "_fmod_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.fmod(other);
+    })
+  .define_method(
+    "_fmod_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.fmod(other);
+    })
+  .define_method(
+    "_frac",
+    *[](const Tensor &self) {
+      return self.frac();
+    })
+  .define_method(
+    "_frac_",
+    *[](Tensor &self) {
+      return self.frac_();
+    })
+  .define_method(
+    "_gather",
+    *[](const Tensor &self, int64_t dim, const Tensor &index, bool sparse_grad) {
+      return self.gather(dim, index, sparse_grad);
+    })
+  .define_method(
+    "_ge__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.ge_(other);
+    })
+  .define_method(
+    "_ge__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.ge_(other);
+    })
+  .define_method(
+    "_ge_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.ge(other);
+    })
+  .define_method(
+    "_ge_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.ge(other);
+    })
+  .define_method(
+    "_geometric_",
+    *[](Tensor &self, double p) {
+      return self.geometric_(p);
+    })
+  .define_method(
+    "_geqrf",
+    *[](const Tensor &self) {
+      return wrap(self.geqrf());
+    })
+  .define_method(
+    "_ger",
+    *[](const Tensor &self, const Tensor &vec2) {
+      return self.ger(vec2);
+    })
+  .define_method(
+    "_gt__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.gt_(other);
+    })
+  .define_method(
+    "_gt__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.gt_(other);
+    })
+  .define_method(
+    "_gt_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.gt(other);
+    })
+  .define_method(
+    "_gt_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.gt(other);
+    })
+  .define_method(
+    "_hardshrink",
+    *[](const Tensor &self, Scalar lambd) {
+      return self.hardshrink(lambd);
+    })
+  .define_method(
+    "_histc",
+    *[](const Tensor &self, int64_t bins, Scalar min, Scalar max) {
+      return self.histc(bins, min, max);
+    })
+  .define_method(
+    "_ifft",
+    *[](const Tensor &self, int64_t signal_ndim, bool normalized) {
+      return self.ifft(signal_ndim, normalized);
+    })
+  .define_method(
+    "_index_add",
+    *[](const Tensor &self, int64_t dim, const Tensor &index, const Tensor &source) {
+      return self.index_add(dim, index, source);
+    })
+  .define_method(
+    "_index_add_",
+    *[](Tensor &self, int64_t dim, const Tensor &index, const Tensor &source) {
+      return self.index_add_(dim, index, source);
+    })
+  .define_method(
+    "_index_copy",
+    *[](const Tensor &self, int64_t dim, const Tensor &index, const Tensor &source) {
+      return self.index_copy(dim, index, source);
+    })
+  .define_method(
+    "_index_copy_",
+    *[](Tensor &self, int64_t dim, const Tensor &index, const Tensor &source) {
+      return self.index_copy_(dim, index, source);
+    })
+  .define_method(
+    "_index_fill__scalar",
+    *[](Tensor &self, int64_t dim, const Tensor &index, Scalar value) {
+      return self.index_fill_(dim, index, value);
+    })
+  .define_method(
+    "_index_fill__tensor",
+    *[](Tensor &self, int64_t dim, const Tensor &index, const Tensor &value) {
+      return self.index_fill_(dim, index, value);
+    })
+  .define_method(
+    "_index_fill_scalar",
+    *[](const Tensor &self, int64_t dim, const Tensor &index, Scalar value) {
+      return self.index_fill(dim, index, value);
+    })
+  .define_method(
+    "_index_fill_tensor",
+    *[](const Tensor &self, int64_t dim, const Tensor &index, const Tensor &value) {
+      return self.index_fill(dim, index, value);
+    })
+  .define_method(
+    "_index_select",
+    *[](const Tensor &self, int64_t dim, const Tensor &index) {
+      return self.index_select(dim, index);
+    })
+  .define_method(
+    "_indices",
+    *[](Tensor &self) {
+      return self.indices();
+    })
+  .define_method(
+    "_int_repr",
+    *[](const Tensor &self) {
+      return self.int_repr();
+    })
+  .define_method(
+    "_inverse",
+    *[](const Tensor &self) {
+      return self.inverse();
+    })
+  .define_method(
+    "_irfft",
+    *[](const Tensor &self, int64_t signal_ndim, bool normalized, bool onesided, IntArrayRef signal_sizes) {
+      return self.irfft(signal_ndim, normalized, onesided, signal_sizes);
+    })
+  .define_method(
+    "_is_coalesced",
+    *[](const Tensor &self) {
+      return self.is_coalesced();
+    })
+  .define_method(
+    "_is_complex",
+    *[](const Tensor &self) {
+      return self.is_complex();
+    })
+  .define_method(
+    "_is_distributed",
+    *[](const Tensor &self) {
+      return self.is_distributed();
+    })
+  .define_method(
+    "_is_floating_point",
+    *[](const Tensor &self) {
+      return self.is_floating_point();
+    })
+  .define_method(
+    "_is_leaf",
+    *[](const Tensor &self) {
+      return self.is_leaf();
+    })
+  .define_method(
+    "_is_nonzero",
+    *[](const Tensor &self) {
+      return self.is_nonzero();
+    })
+  .define_method(
+    "_is_pinned",
+    *[](const Tensor &self) {
+      return self.is_pinned();
+    })
+  .define_method(
+    "_is_same_size",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.is_same_size(other);
+    })
+  .define_method(
+    "_is_set_to",
+    *[](const Tensor &self, const Tensor &tensor) {
+      return self.is_set_to(tensor);
+    })
+  .define_method(
+    "_is_signed",
+    *[](const Tensor &self) {
+      return self.is_signed();
+    })
+  .define_method(
+    "_isclose",
+    *[](const Tensor &self, const Tensor &other, double rtol, double atol, bool equal_nan) {
+      return self.isclose(other, rtol, atol, equal_nan);
+    })
+  .define_method(
+    "_item",
+    *[](const Tensor &self) {
+      return self.item();
+    })
+  .define_method(
+    "_kthvalue",
+    *[](const Tensor &self, int64_t k, int64_t dim, bool keepdim) {
+      return wrap(self.kthvalue(k, dim, keepdim));
+    })
+  .define_method(
+    "_le__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.le_(other);
+    })
+  .define_method(
+    "_le__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.le_(other);
+    })
+  .define_method(
+    "_le_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.le(other);
+    })
+  .define_method(
+    "_le_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.le(other);
+    })
+  .define_method(
+    "_lerp__scalar",
+    *[](Tensor &self, const Tensor &end, Scalar weight) {
+      return self.lerp_(end, weight);
+    })
+  .define_method(
+    "_lerp__tensor",
+    *[](Tensor &self, const Tensor &end, const Tensor &weight) {
+      return self.lerp_(end, weight);
+    })
+  .define_method(
+    "_lerp_scalar",
+    *[](const Tensor &self, const Tensor &end, Scalar weight) {
+      return self.lerp(end, weight);
+    })
+  .define_method(
+    "_lerp_tensor",
+    *[](const Tensor &self, const Tensor &end, const Tensor &weight) {
+      return self.lerp(end, weight);
+    })
+  .define_method(
+    "_lgamma",
+    *[](const Tensor &self) {
+      return self.lgamma();
+    })
+  .define_method(
+    "_lgamma_",
+    *[](Tensor &self) {
+      return self.lgamma_();
+    })
+  .define_method(
+    "_log",
+    *[](const Tensor &self) {
+      return self.log();
+    })
+  .define_method(
+    "_log10",
+    *[](const Tensor &self) {
+      return self.log10();
+    })
+  .define_method(
+    "_log10_",
+    *[](Tensor &self) {
+      return self.log10_();
+    })
+  .define_method(
+    "_log1p",
+    *[](const Tensor &self) {
+      return self.log1p();
+    })
+  .define_method(
+    "_log1p_",
+    *[](Tensor &self) {
+      return self.log1p_();
+    })
+  .define_method(
+    "_log2",
+    *[](const Tensor &self) {
+      return self.log2();
+    })
+  .define_method(
+    "_log2_",
+    *[](Tensor &self) {
+      return self.log2_();
+    })
+  .define_method(
+    "_log_",
+    *[](Tensor &self) {
+      return self.log_();
+    })
+  .define_method(
+    "_log_normal_",
+    *[](Tensor &self, double mean, double std) {
+      return self.log_normal_(mean, std);
+    })
+  .define_method(
+    "_log_softmax",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype) {
+      return self.log_softmax(dim, dtype);
+    })
+  .define_method(
+    "_logdet",
+    *[](const Tensor &self) {
+      return self.logdet();
+    })
+  .define_method(
+    "_logical_not",
+    *[](const Tensor &self) {
+      return self.logical_not();
+    })
+  .define_method(
+    "_logical_not_",
+    *[](Tensor &self) {
+      return self.logical_not_();
+    })
+  .define_method(
+    "_logical_xor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.logical_xor(other);
+    })
+  .define_method(
+    "_logical_xor_",
+    *[](Tensor &self, const Tensor &other) {
+      return self.logical_xor_(other);
+    })
+  .define_method(
+    "_logsumexp",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim) {
+      return self.logsumexp(dim, keepdim);
+    })
+  .define_method(
+    "_lstsq",
+    *[](const Tensor &self, const Tensor &A) {
+      return wrap(self.lstsq(A));
+    })
+  .define_method(
+    "_lt__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.lt_(other);
+    })
+  .define_method(
+    "_lt__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.lt_(other);
+    })
+  .define_method(
+    "_lt_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.lt(other);
+    })
+  .define_method(
+    "_lt_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.lt(other);
+    })
+  .define_method(
+    "_lu_solve",
+    *[](const Tensor &self, const Tensor &LU_data, const Tensor &LU_pivots) {
+      return self.lu_solve(LU_data, LU_pivots);
+    })
+  .define_method(
+    "_masked_fill__scalar",
+    *[](Tensor &self, const Tensor &mask, Scalar value) {
+      return self.masked_fill_(mask, value);
+    })
+  .define_method(
+    "_masked_fill__tensor",
+    *[](Tensor &self, const Tensor &mask, const Tensor &value) {
+      return self.masked_fill_(mask, value);
+    })
+  .define_method(
+    "_masked_fill_scalar",
+    *[](const Tensor &self, const Tensor &mask, Scalar value) {
+      return self.masked_fill(mask, value);
+    })
+  .define_method(
+    "_masked_fill_tensor",
+    *[](const Tensor &self, const Tensor &mask, const Tensor &value) {
+      return self.masked_fill(mask, value);
+    })
+  .define_method(
+    "_masked_scatter",
+    *[](const Tensor &self, const Tensor &mask, const Tensor &source) {
+      return self.masked_scatter(mask, source);
+    })
+  .define_method(
+    "_masked_scatter_",
+    *[](Tensor &self, const Tensor &mask, const Tensor &source) {
+      return self.masked_scatter_(mask, source);
+    })
+  .define_method(
+    "_masked_select",
+    *[](const Tensor &self, const Tensor &mask) {
+      return self.masked_select(mask);
+    })
+  .define_method(
+    "_matmul",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.matmul(other);
+    })
+  .define_method(
+    "_matrix_power",
+    *[](const Tensor &self, int64_t n) {
+      return self.matrix_power(n);
+    })
+  .define_method(
+    "_max",
+    *[](const Tensor &self) {
+      return self.max();
+    })
+  .define_method(
+    "_max_dim",
+    *[](const Tensor &self, int64_t dim, bool keepdim) {
+      return wrap(self.max(dim, keepdim));
+    })
+  .define_method(
+    "_max_other",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.max(other);
+    })
+  .define_method(
+    "_max_values",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim) {
+      return self.max_values(dim, keepdim);
+    })
+  .define_method(
+    "_mean",
+    *[](const Tensor &self, OptionalScalarType dtype) {
+      return self.mean(dtype);
+    })
+  .define_method(
+    "_mean_dim",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim, OptionalScalarType dtype) {
+      return self.mean(dim, keepdim, dtype);
+    })
+  .define_method(
+    "_median",
+    *[](const Tensor &self) {
+      return self.median();
+    })
+  .define_method(
+    "_median_dim",
+    *[](const Tensor &self, int64_t dim, bool keepdim) {
+      return wrap(self.median(dim, keepdim));
+    })
+  .define_method(
+    "_min",
+    *[](const Tensor &self) {
+      return self.min();
+    })
+  .define_method(
+    "_min_dim",
+    *[](const Tensor &self, int64_t dim, bool keepdim) {
+      return wrap(self.min(dim, keepdim));
+    })
+  .define_method(
+    "_min_other",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.min(other);
+    })
+  .define_method(
+    "_min_values",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim) {
+      return self.min_values(dim, keepdim);
+    })
+  .define_method(
+    "_mm",
+    *[](const Tensor &self, const Tensor &mat2) {
+      return self.mm(mat2);
+    })
+  .define_method(
+    "_mode",
+    *[](const Tensor &self, int64_t dim, bool keepdim) {
+      return wrap(self.mode(dim, keepdim));
+    })
+  .define_method(
+    "_mul__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.mul_(other);
+    })
+  .define_method(
+    "_mul__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.mul_(other);
+    })
+  .define_method(
+    "_mul_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.mul(other);
+    })
+  .define_method(
+    "_mul_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.mul(other);
+    })
+  .define_method(
+    "_multinomial",
+    *[](const Tensor &self, int64_t num_samples, bool replacement) {
+      return self.multinomial(num_samples, replacement);
+    })
+  .define_method(
+    "_mv",
+    *[](const Tensor &self, const Tensor &vec) {
+      return self.mv(vec);
+    })
+  .define_method(
+    "_mvlgamma",
+    *[](const Tensor &self, int64_t p) {
+      return self.mvlgamma(p);
+    })
+  .define_method(
+    "_mvlgamma_",
+    *[](Tensor &self, int64_t p) {
+      return self.mvlgamma_(p);
+    })
+  .define_method(
+    "_narrow",
+    *[](Tensor &self, int64_t dim, int64_t start, int64_t length) {
+      return self.narrow(dim, start, length);
+    })
+  .define_method(
+    "_narrow_copy",
+    *[](const Tensor &self, int64_t dim, int64_t start, int64_t length) {
+      return self.narrow_copy(dim, start, length);
+    })
+  .define_method(
+    "_ne__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.ne_(other);
+    })
+  .define_method(
+    "_ne__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.ne_(other);
+    })
+  .define_method(
+    "_ne_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.ne(other);
+    })
+  .define_method(
+    "_ne_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.ne(other);
+    })
+  .define_method(
+    "_neg",
+    *[](const Tensor &self) {
+      return self.neg();
+    })
+  .define_method(
+    "_neg_",
+    *[](Tensor &self) {
+      return self.neg_();
+    })
+  .define_method(
+    "_nonzero",
+    *[](const Tensor &self) {
+      return self.nonzero();
+    })
+  .define_method(
+    "_nonzero_numpy",
+    *[](const Tensor &self) {
+      return self.nonzero_numpy();
+    })
+  .define_method(
+    "_norm_scalar",
+    *[](const Tensor &self, Scalar p) {
+      return self.norm(p);
+    })
+  .define_method(
+    "_normal_",
+    *[](Tensor &self, double mean, double std) {
+      return self.normal_(mean, std);
+    })
+  .define_method(
+    "_numel",
+    *[](const Tensor &self) {
+      return self.numel();
+    })
+  .define_method(
+    "_numpy_t",
+    *[](Tensor &self) {
+      return self.numpy_T();
+    })
+  .define_method(
+    "_orgqr",
+    *[](const Tensor &self, const Tensor &input2) {
+      return self.orgqr(input2);
+    })
+  .define_method(
+    "_ormqr",
+    *[](const Tensor &self, const Tensor &input2, const Tensor &input3, bool left, bool transpose) {
+      return self.ormqr(input2, input3, left, transpose);
+    })
+  .define_method(
+    "_output_nr",
+    *[](const Tensor &self) {
+      return self.output_nr();
+    })
+  .define_method(
+    "_permute",
+    *[](Tensor &self, IntArrayRef dims) {
+      return self.permute(dims);
+    })
+  .define_method(
+    "_pin_memory",
+    *[](const Tensor &self) {
+      return self.pin_memory();
+    })
+  .define_method(
+    "_pinverse",
+    *[](const Tensor &self, double rcond) {
+      return self.pinverse(rcond);
+    })
+  .define_method(
+    "_polygamma",
+    *[](int64_t n, const Tensor &self) {
+      return self.polygamma(n);
+    })
+  .define_method(
+    "_polygamma_",
+    *[](Tensor &self, int64_t n) {
+      return self.polygamma_(n);
+    })
+  .define_method(
+    "_pow__scalar",
+    *[](Tensor &self, Scalar exponent) {
+      return self.pow_(exponent);
+    })
+  .define_method(
+    "_pow__tensor",
+    *[](Tensor &self, const Tensor &exponent) {
+      return self.pow_(exponent);
+    })
+  .define_method(
+    "_pow_tensor_scalar",
+    *[](const Tensor &self, Scalar exponent) {
+      return self.pow(exponent);
+    })
+  .define_method(
+    "_pow_tensor_tensor",
+    *[](const Tensor &self, const Tensor &exponent) {
+      return self.pow(exponent);
+    })
+  .define_method(
+    "_prelu",
+    *[](const Tensor &self, const Tensor &weight) {
+      return self.prelu(weight);
+    })
+  .define_method(
+    "_prod",
+    *[](const Tensor &self, OptionalScalarType dtype) {
+      return self.prod(dtype);
+    })
+  .define_method(
+    "_prod_dim_int",
+    *[](const Tensor &self, int64_t dim, bool keepdim, OptionalScalarType dtype) {
+      return self.prod(dim, keepdim, dtype);
+    })
+  .define_method(
+    "_put_",
+    *[](Tensor &self, const Tensor &index, const Tensor &source, bool accumulate) {
+      return self.put_(index, source, accumulate);
+    })
+  .define_method(
+    "_q_per_channel_axis",
+    *[](const Tensor &self) {
+      return self.q_per_channel_axis();
+    })
+  .define_method(
+    "_q_per_channel_scales",
+    *[](const Tensor &self) {
+      return self.q_per_channel_scales();
+    })
+  .define_method(
+    "_q_per_channel_zero_points",
+    *[](const Tensor &self) {
+      return self.q_per_channel_zero_points();
+    })
+  .define_method(
+    "_q_scale",
+    *[](const Tensor &self) {
+      return self.q_scale();
+    })
+  .define_method(
+    "_q_zero_point",
+    *[](const Tensor &self) {
+      return self.q_zero_point();
+    })
+  .define_method(
+    "_qr",
+    *[](const Tensor &self, bool some) {
+      return wrap(self.qr(some));
+    })
+  .define_method(
+    "_qscheme",
+    *[](const Tensor &self) {
+      return self.qscheme();
+    })
+  .define_method(
+    "_random_",
+    *[](Tensor &self) {
+      return self.random_();
+    })
+  .define_method(
+    "_random__from",
+    *[](Tensor &self, int64_t from, int64_t to) {
+      return self.random_(from, to);
+    })
+  .define_method(
+    "_random__to",
+    *[](Tensor &self, int64_t to) {
+      return self.random_(to);
+    })
+  .define_method(
+    "_reciprocal",
+    *[](const Tensor &self) {
+      return self.reciprocal();
+    })
+  .define_method(
+    "_reciprocal_",
+    *[](Tensor &self) {
+      return self.reciprocal_();
+    })
+  .define_method(
+    "_relu",
+    *[](const Tensor &self) {
+      return self.relu();
+    })
+  .define_method(
+    "_relu_",
+    *[](Tensor &self) {
+      return self.relu_();
+    })
+  .define_method(
+    "_remainder__scalar",
+    *[](Tensor &self, Scalar other) {
+      return self.remainder_(other);
+    })
+  .define_method(
+    "_remainder__tensor",
+    *[](Tensor &self, const Tensor &other) {
+      return self.remainder_(other);
+    })
+  .define_method(
+    "_remainder_scalar",
+    *[](const Tensor &self, Scalar other) {
+      return self.remainder(other);
+    })
+  .define_method(
+    "_remainder_tensor",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.remainder(other);
+    })
+  .define_method(
+    "_renorm",
+    *[](const Tensor &self, Scalar p, int64_t dim, Scalar maxnorm) {
+      return self.renorm(p, dim, maxnorm);
+    })
+  .define_method(
+    "_renorm_",
+    *[](Tensor &self, Scalar p, int64_t dim, Scalar maxnorm) {
+      return self.renorm_(p, dim, maxnorm);
+    })
+  .define_method(
+    "_repeat",
+    *[](const Tensor &self, IntArrayRef repeats) {
+      return self.repeat(repeats);
+    })
+  .define_method(
+    "_repeat_interleave_self_int",
+    *[](const Tensor &self, int64_t repeats) {
+      return self.repeat_interleave(repeats);
+    })
+  .define_method(
+    "_repeat_interleave_self_int_dim",
+    *[](const Tensor &self, int64_t repeats, int64_t dim) {
+      return self.repeat_interleave(repeats, dim);
+    })
+  .define_method(
+    "_repeat_interleave_self_tensor",
+    *[](const Tensor &self, const Tensor &repeats) {
+      return self.repeat_interleave(repeats);
+    })
+  .define_method(
+    "_repeat_interleave_self_tensor_dim",
+    *[](const Tensor &self, const Tensor &repeats, int64_t dim) {
+      return self.repeat_interleave(repeats, dim);
+    })
+  .define_method(
+    "_reshape",
+    *[](const Tensor &self, IntArrayRef shape) {
+      return self.reshape(shape);
+    })
+  .define_method(
+    "_reshape_as",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.reshape_as(other);
+    })
+  .define_method(
+    "_resize_",
+    *[](Tensor &self, IntArrayRef size) {
+      return self.resize_(size);
+    })
+  .define_method(
+    "_resize_as_",
+    *[](Tensor &self, const Tensor &the_template) {
+      return self.resize_as_(the_template);
+    })
+  .define_method(
+    "_rfft",
+    *[](const Tensor &self, int64_t signal_ndim, bool normalized, bool onesided) {
+      return self.rfft(signal_ndim, normalized, onesided);
+    })
+  .define_method(
+    "_roll",
+    *[](const Tensor &self, IntArrayRef shifts, IntArrayRef dims) {
+      return self.roll(shifts, dims);
+    })
+  .define_method(
+    "_rot90",
+    *[](const Tensor &self, int64_t k, IntArrayRef dims) {
+      return self.rot90(k, dims);
+    })
+  .define_method(
+    "_round",
+    *[](const Tensor &self) {
+      return self.round();
+    })
+  .define_method(
+    "_round_",
+    *[](Tensor &self) {
+      return self.round_();
+    })
+  .define_method(
+    "_rsqrt",
+    *[](const Tensor &self) {
+      return self.rsqrt();
+    })
+  .define_method(
+    "_rsqrt_",
+    *[](Tensor &self) {
+      return self.rsqrt_();
+    })
+  .define_method(
+    "_scatter__src",
+    *[](Tensor &self, int64_t dim, const Tensor &index, const Tensor &src) {
+      return self.scatter_(dim, index, src);
+    })
+  .define_method(
+    "_scatter__value",
+    *[](Tensor &self, int64_t dim, const Tensor &index, Scalar value) {
+      return self.scatter_(dim, index, value);
+    })
+  .define_method(
+    "_scatter_add",
+    *[](const Tensor &self, int64_t dim, const Tensor &index, const Tensor &src) {
+      return self.scatter_add(dim, index, src);
+    })
+  .define_method(
+    "_scatter_add_",
+    *[](Tensor &self, int64_t dim, const Tensor &index, const Tensor &src) {
+      return self.scatter_add_(dim, index, src);
+    })
+  .define_method(
+    "_scatter_src",
+    *[](const Tensor &self, int64_t dim, const Tensor &index, const Tensor &src) {
+      return self.scatter(dim, index, src);
+    })
+  .define_method(
+    "_scatter_value",
+    *[](const Tensor &self, int64_t dim, const Tensor &index, Scalar value) {
+      return self.scatter(dim, index, value);
+    })
+  .define_method(
+    "_select_int",
+    *[](Tensor &self, int64_t dim, int64_t index) {
+      return self.select(dim, index);
+    })
+  .define_method(
+    "_set_",
+    *[](Tensor &self) {
+      return self.set_();
+    })
+  .define_method(
+    "_set__source_tensor",
+    *[](Tensor &self, const Tensor &source) {
+      return self.set_(source);
+    })
+  .define_method(
+    "_set_data",
+    *[](Tensor &self, const Tensor &new_data) {
+      return self.set_data(new_data);
+    })
+  .define_method(
+    "_sigmoid",
+    *[](const Tensor &self) {
+      return self.sigmoid();
+    })
+  .define_method(
+    "_sigmoid_",
+    *[](Tensor &self) {
+      return self.sigmoid_();
+    })
+  .define_method(
+    "_sign",
+    *[](const Tensor &self) {
+      return self.sign();
+    })
+  .define_method(
+    "_sign_",
+    *[](Tensor &self) {
+      return self.sign_();
+    })
+  .define_method(
+    "_sin",
+    *[](const Tensor &self) {
+      return self.sin();
+    })
+  .define_method(
+    "_sin_",
+    *[](Tensor &self) {
+      return self.sin_();
+    })
+  .define_method(
+    "_sinh",
+    *[](const Tensor &self) {
+      return self.sinh();
+    })
+  .define_method(
+    "_sinh_",
+    *[](Tensor &self) {
+      return self.sinh_();
+    })
+  .define_method(
+    "_size_int",
+    *[](const Tensor &self, int64_t dim) {
+      return self.size(dim);
+    })
+  .define_method(
+    "_slice_tensor",
+    *[](Tensor &self, int64_t dim, int64_t start, int64_t end, int64_t step) {
+      return self.slice(dim, start, end, step);
+    })
+  .define_method(
+    "_slogdet",
+    *[](const Tensor &self) {
+      return wrap(self.slogdet());
+    })
+  .define_method(
+    "_smm",
+    *[](const Tensor &self, const Tensor &mat2) {
+      return self.smm(mat2);
+    })
+  .define_method(
+    "_softmax",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype) {
+      return self.softmax(dim, dtype);
+    })
+  .define_method(
+    "_solve",
+    *[](const Tensor &self, const Tensor &A) {
+      return wrap(self.solve(A));
+    })
+  .define_method(
+    "_sort",
+    *[](const Tensor &self, int64_t dim, bool descending) {
+      return wrap(self.sort(dim, descending));
+    })
+  .define_method(
+    "_sparse_dim",
+    *[](const Tensor &self) {
+      return self.sparse_dim();
+    })
+  .define_method(
+    "_sparse_mask",
+    *[](const Tensor &self, const Tensor &mask) {
+      return self.sparse_mask(mask);
+    })
+  .define_method(
+    "_sparse_resize_",
+    *[](Tensor &self, IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) {
+      return self.sparse_resize_(size, sparse_dim, dense_dim);
+    })
+  .define_method(
+    "_sparse_resize_and_clear_",
+    *[](Tensor &self, IntArrayRef size, int64_t sparse_dim, int64_t dense_dim) {
+      return self.sparse_resize_and_clear_(size, sparse_dim, dense_dim);
+    })
+  .define_method(
+    "_split_tensor",
+    *[](Tensor &self, int64_t split_size, int64_t dim) {
+      return self.split(split_size, dim);
+    })
+  .define_method(
+    "_split_with_sizes",
+    *[](const Tensor &self, IntArrayRef split_sizes, int64_t dim) {
+      return self.split_with_sizes(split_sizes, dim);
+    })
+  .define_method(
+    "_sqrt",
+    *[](const Tensor &self) {
+      return self.sqrt();
+    })
+  .define_method(
+    "_sqrt_",
+    *[](Tensor &self) {
+      return self.sqrt_();
+    })
+  .define_method(
+    "_squeeze",
+    *[](Tensor &self) {
+      return self.squeeze();
+    })
+  .define_method(
+    "_squeeze_",
+    *[](Tensor &self) {
+      return self.squeeze_();
+    })
+  .define_method(
+    "_squeeze__dim",
+    *[](Tensor &self, int64_t dim) {
+      return self.squeeze_(dim);
+    })
+  .define_method(
+    "_squeeze_dim",
+    *[](Tensor &self, int64_t dim) {
+      return self.squeeze(dim);
+    })
+  .define_method(
+    "_sspaddmm",
+    *[](const Tensor &self, const Tensor &mat1, const Tensor &mat2, Scalar beta, Scalar alpha) {
+      return self.sspaddmm(mat1, mat2, beta, alpha);
+    })
+  .define_method(
+    "_std",
+    *[](const Tensor &self, bool unbiased) {
+      return self.std(unbiased);
+    })
+  .define_method(
+    "_std_dim",
+    *[](const Tensor &self, IntArrayRef dim, bool unbiased, bool keepdim) {
+      return self.std(dim, unbiased, keepdim);
+    })
+  .define_method(
+    "_stride_int",
+    *[](const Tensor &self, int64_t dim) {
+      return self.stride(dim);
+    })
+  .define_method(
+    "_sub__scalar",
+    *[](Tensor &self, Scalar other, Scalar alpha) {
+      return self.sub_(other, alpha);
+    })
+  .define_method(
+    "_sub__tensor",
+    *[](Tensor &self, const Tensor &other, Scalar alpha) {
+      return self.sub_(other, alpha);
+    })
+  .define_method(
+    "_sub_scalar",
+    *[](const Tensor &self, Scalar other, Scalar alpha) {
+      return self.sub(other, alpha);
+    })
+  .define_method(
+    "_sub_tensor",
+    *[](const Tensor &self, const Tensor &other, Scalar alpha) {
+      return self.sub(other, alpha);
+    })
+  .define_method(
+    "_sum",
+    *[](const Tensor &self, OptionalScalarType dtype) {
+      return self.sum(dtype);
+    })
+  .define_method(
+    "_sum_dim_intlist",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim, OptionalScalarType dtype) {
+      return self.sum(dim, keepdim, dtype);
+    })
+  .define_method(
+    "_sum_to_size",
+    *[](const Tensor &self, IntArrayRef size) {
+      return self.sum_to_size(size);
+    })
+  .define_method(
+    "_svd",
+    *[](const Tensor &self, bool some, bool compute_uv) {
+      return wrap(self.svd(some, compute_uv));
+    })
+  .define_method(
+    "_symeig",
+    *[](const Tensor &self, bool eigenvectors, bool upper) {
+      return wrap(self.symeig(eigenvectors, upper));
+    })
+  .define_method(
+    "_t",
+    *[](Tensor &self) {
+      return self.t();
+    })
+  .define_method(
+    "_t_",
+    *[](Tensor &self) {
+      return self.t_();
+    })
+  .define_method(
+    "_take",
+    *[](const Tensor &self, const Tensor &index) {
+      return self.take(index);
+    })
+  .define_method(
+    "_tan",
+    *[](const Tensor &self) {
+      return self.tan();
+    })
+  .define_method(
+    "_tan_",
+    *[](Tensor &self) {
+      return self.tan_();
+    })
+  .define_method(
+    "_tanh",
+    *[](const Tensor &self) {
+      return self.tanh();
+    })
+  .define_method(
+    "_tanh_",
+    *[](Tensor &self) {
+      return self.tanh_();
+    })
+  .define_method(
+    "_to_dense",
+    *[](const Tensor &self) {
+      return self.to_dense();
+    })
+  .define_method(
+    "_to_device",
+    *[](const Tensor &self, Device device, ScalarType dtype, bool non_blocking, bool copy) {
+      return self.to(device, dtype, non_blocking, copy);
+    })
+  .define_method(
+    "_to_dtype",
+    *[](const Tensor &self, ScalarType dtype, bool non_blocking, bool copy) {
+      return self.to(dtype, non_blocking, copy);
+    })
+  .define_method(
+    "_to_mkldnn",
+    *[](const Tensor &self) {
+      return self.to_mkldnn();
+    })
+  .define_method(
+    "_to_other",
+    *[](const Tensor &self, const Tensor &other, bool non_blocking, bool copy) {
+      return self.to(other, non_blocking, copy);
+    })
+  .define_method(
+    "_to_sparse",
+    *[](const Tensor &self) {
+      return self.to_sparse();
+    })
+  .define_method(
+    "_to_sparse_sparse_dim",
+    *[](const Tensor &self, int64_t sparse_dim) {
+      return self.to_sparse(sparse_dim);
+    })
+  .define_method(
+    "_topk",
+    *[](const Tensor &self, int64_t k, int64_t dim, bool largest, bool sorted) {
+      return wrap(self.topk(k, dim, largest, sorted));
+    })
+  .define_method(
+    "_trace",
+    *[](const Tensor &self) {
+      return self.trace();
+    })
+  .define_method(
+    "_transpose_",
+    *[](Tensor &self, int64_t dim0, int64_t dim1) {
+      return self.transpose_(dim0, dim1);
+    })
+  .define_method(
+    "_transpose_int",
+    *[](Tensor &self, int64_t dim0, int64_t dim1) {
+      return self.transpose(dim0, dim1);
+    })
+  .define_method(
+    "_triangular_solve",
+    *[](const Tensor &self, const Tensor &A, bool upper, bool transpose, bool unitriangular) {
+      return wrap(self.triangular_solve(A, upper, transpose, unitriangular));
+    })
+  .define_method(
+    "_tril",
+    *[](const Tensor &self, int64_t diagonal) {
+      return self.tril(diagonal);
+    })
+  .define_method(
+    "_tril_",
+    *[](Tensor &self, int64_t diagonal) {
+      return self.tril_(diagonal);
+    })
+  .define_method(
+    "_triu",
+    *[](const Tensor &self, int64_t diagonal) {
+      return self.triu(diagonal);
+    })
+  .define_method(
+    "_triu_",
+    *[](Tensor &self, int64_t diagonal) {
+      return self.triu_(diagonal);
+    })
+  .define_method(
+    "_trunc",
+    *[](const Tensor &self) {
+      return self.trunc();
+    })
+  .define_method(
+    "_trunc_",
+    *[](Tensor &self) {
+      return self.trunc_();
+    })
+  .define_method(
+    "_type_as",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.type_as(other);
+    })
+  .define_method(
+    "_unbind_int",
+    *[](Tensor &self, int64_t dim) {
+      return self.unbind(dim);
+    })
+  .define_method(
+    "_unfold",
+    *[](Tensor &self, int64_t dimension, int64_t size, int64_t step) {
+      return self.unfold(dimension, size, step);
+    })
+  .define_method(
+    "_uniform_",
+    *[](Tensor &self, double from, double to) {
+      return self.uniform_(from, to);
+    })
+  .define_method(
+    "_unsqueeze",
+    *[](Tensor &self, int64_t dim) {
+      return self.unsqueeze(dim);
+    })
+  .define_method(
+    "_unsqueeze_",
+    *[](Tensor &self, int64_t dim) {
+      return self.unsqueeze_(dim);
+    })
+  .define_method(
+    "_values",
+    *[](Tensor &self) {
+      return self.values();
+    })
+  .define_method(
+    "_var",
+    *[](const Tensor &self, bool unbiased) {
+      return self.var(unbiased);
+    })
+  .define_method(
+    "_var_dim",
+    *[](const Tensor &self, IntArrayRef dim, bool unbiased, bool keepdim) {
+      return self.var(dim, unbiased, keepdim);
+    })
+  .define_method(
+    "_view",
+    *[](Tensor &self, IntArrayRef size) {
+      return self.view(size);
+    })
+  .define_method(
+    "_view_as",
+    *[](const Tensor &self, const Tensor &other) {
+      return self.view_as(other);
+    })
+  .define_method(
+    "_where_self",
+    *[](const Tensor &condition, const Tensor &self, const Tensor &other) {
+      return self.where(condition, other);
+    })
+  .define_method(
+    "_zero_",
+    *[](Tensor &self) {
+      return self.zero_();
+    });
+}