torch-rb 0.2.0 → 0.2.5

data/ext/torch/nn_functions.hpp

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

data/ext/torch/tensor_functions.cpp

@@ -1,2085 +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_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(
-    "_angle",
-    *[](const Tensor &self) {
-      return self.angle();
-    })
-  .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_and__scalar",
-    *[](Tensor &self, Scalar other) {
-      return self.bitwise_and_(other);
-    })
-  .define_method(
-    "_bitwise_and__tensor",
-    *[](Tensor &self, const Tensor &other) {
-      return self.bitwise_and_(other);
-    })
-  .define_method(
-    "_bitwise_and_scalar",
-    *[](const Tensor &self, Scalar other) {
-      return self.bitwise_and(other);
-    })
-  .define_method(
-    "_bitwise_and_tensor",
-    *[](const Tensor &self, const Tensor &other) {
-      return self.bitwise_and(other);
-    })
-  .define_method(
-    "_bitwise_not",
-    *[](const Tensor &self) {
-      return self.bitwise_not();
-    })
-  .define_method(
-    "_bitwise_not_",
-    *[](Tensor &self) {
-      return self.bitwise_not_();
-    })
-  .define_method(
-    "_bitwise_or__scalar",
-    *[](Tensor &self, Scalar other) {
-      return self.bitwise_or_(other);
-    })
-  .define_method(
-    "_bitwise_or__tensor",
-    *[](Tensor &self, const Tensor &other) {
-      return self.bitwise_or_(other);
-    })
-  .define_method(
-    "_bitwise_or_scalar",
-    *[](const Tensor &self, Scalar other) {
-      return self.bitwise_or(other);
-    })
-  .define_method(
-    "_bitwise_or_tensor",
-    *[](const Tensor &self, const Tensor &other) {
-      return self.bitwise_or(other);
-    })
-  .define_method(
-    "_bitwise_xor__scalar",
-    *[](Tensor &self, Scalar other) {
-      return self.bitwise_xor_(other);
-    })
-  .define_method(
-    "_bitwise_xor__tensor",
-    *[](Tensor &self, const Tensor &other) {
-      return self.bitwise_xor_(other);
-    })
-  .define_method(
-    "_bitwise_xor_scalar",
-    *[](const Tensor &self, Scalar other) {
-      return self.bitwise_xor(other);
-    })
-  .define_method(
-    "_bitwise_xor_tensor",
-    *[](const Tensor &self, const Tensor &other) {
-      return self.bitwise_xor(other);
-    })
-  .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(
-    "_conj",
-    *[](const Tensor &self) {
-      return self.conj();
-    })
-  .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(
-    "_cummax",
-    *[](const Tensor &self, int64_t dim) {
-      return wrap(self.cummax(dim));
-    })
-  .define_method(
-    "_cummin",
-    *[](const Tensor &self, int64_t dim) {
-      return wrap(self.cummin(dim));
-    })
-  .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(
-    "_floor_divide",
-    *[](const Tensor &self, const Tensor &other) {
-      return self.floor_divide(other);
-    })
-  .define_method(
-    "_floor_divide__scalar",
-    *[](Tensor &self, Scalar other) {
-      return self.floor_divide_(other);
-    })
-  .define_method(
-    "_floor_divide__tensor",
-    *[](Tensor &self, const Tensor &other) {
-      return self.floor_divide_(other);
-    })
-  .define_method(
-    "_floor_divide_scalar",
-    *[](const Tensor &self, Scalar other) {
-      return self.floor_divide(other);
-    })
-  .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__int_scalar",
-    *[](Tensor &self, int64_t dim, const Tensor &index, Scalar value) {
-      return self.index_fill_(dim, index, value);
-    })
-  .define_method(
-    "_index_fill__int_tensor",
-    *[](Tensor &self, int64_t dim, const Tensor &index, const Tensor &value) {
-      return self.index_fill_(dim, index, value);
-    })
-  .define_method(
-    "_index_fill_int_scalar",
-    *[](const Tensor &self, int64_t dim, const Tensor &index, Scalar value) {
-      return self.index_fill(dim, index, value);
-    })
-  .define_method(
-    "_index_fill_int_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_int",
-    *[](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_and",
-    *[](const Tensor &self, const Tensor &other) {
-      return self.logical_and(other);
-    })
-  .define_method(
-    "_logical_and_",
-    *[](Tensor &self, const Tensor &other) {
-      return self.logical_and_(other);
-    })
-  .define_method(
-    "_logical_not",
-    *[](const Tensor &self) {
-      return self.logical_not();
-    })
-  .define_method(
-    "_logical_not_",
-    *[](Tensor &self) {
-      return self.logical_not_();
-    })
-  .define_method(
-    "_logical_or",
-    *[](const Tensor &self, const Tensor &other) {
-      return self.logical_or(other);
-    })
-  .define_method(
-    "_logical_or_",
-    *[](Tensor &self, const Tensor &other) {
-      return self.logical_or_(other);
-    })
-  .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(
-    "_narrow_tensor",
-    *[](Tensor &self, int64_t dim, const Tensor &start, int64_t length) {
-      return self.narrow(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(
-    "_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) {
-      return self.random_(from);
-    })
-  .define_method(
-    "_random__from_to",
-    *[](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(
-    "_requires_grad_",
-    *[](Tensor &self, bool _requires_grad) {
-      return self.requires_grad_(_requires_grad);
-    })
-  .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(
-    "_retain_grad",
-    *[](Tensor &self) {
-      return self.retain_grad();
-    })
-  .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_int",
-    *[](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(
-    "_square",
-    *[](const Tensor &self) {
-      return self.square();
-    })
-  .define_method(
-    "_square_",
-    *[](Tensor &self) {
-      return self.square_();
-    })
-  .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(
-    "_true_divide__scalar",
-    *[](Tensor &self, Scalar other) {
-      return self.true_divide_(other);
-    })
-  .define_method(
-    "_true_divide__tensor",
-    *[](Tensor &self, const Tensor &other) {
-      return self.true_divide_(other);
-    })
-  .define_method(
-    "_true_divide_scalar",
-    *[](const Tensor &self, Scalar other) {
-      return self.true_divide(other);
-    })
-  .define_method(
-    "_true_divide_tensor",
-    *[](const Tensor &self, const Tensor &other) {
-      return self.true_divide(other);
-    })
-  .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_();
-    });
-}