torch-rb 0.1.5 → 0.1.6

data/ext/torch/templates.hpp

@@ -248,3 +248,51 @@ 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

@@ -362,6 +362,16 @@ void add_tensor_functions(Module m) {
     *[](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) {
@@ -455,7 +465,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_eig",
     *[](const Tensor &self, bool eigenvectors) {
-      return self.eig(eigenvectors);
+      return wrap(self.eig(eigenvectors));
     })
   .define_method(
     "_eq__scalar",
@@ -650,7 +660,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_geqrf",
     *[](const Tensor &self) {
-      return self.geqrf();
+      return wrap(self.geqrf());
     })
   .define_method(
     "_ger",
@@ -820,7 +830,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_kthvalue",
     *[](const Tensor &self, int64_t k, int64_t dim, bool keepdim) {
-      return self.kthvalue(k, dim, keepdim);
+      return wrap(self.kthvalue(k, dim, keepdim));
     })
   .define_method(
     "_le__scalar",
@@ -917,6 +927,11 @@ void add_tensor_functions(Module m) {
     *[](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) {
@@ -950,7 +965,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_lstsq",
     *[](const Tensor &self, const Tensor &A) {
-      return self.lstsq(A);
+      return wrap(self.lstsq(A));
     })
   .define_method(
     "_lt__scalar",
@@ -1030,7 +1045,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_max_dim",
     *[](const Tensor &self, int64_t dim, bool keepdim) {
-      return self.max(dim, keepdim);
+      return wrap(self.max(dim, keepdim));
     })
   .define_method(
     "_max_other",
@@ -1042,6 +1057,16 @@ void add_tensor_functions(Module m) {
     *[](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) {
@@ -1050,7 +1075,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_median_dim",
     *[](const Tensor &self, int64_t dim, bool keepdim) {
-      return self.median(dim, keepdim);
+      return wrap(self.median(dim, keepdim));
     })
   .define_method(
     "_min",
@@ -1060,7 +1085,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_min_dim",
     *[](const Tensor &self, int64_t dim, bool keepdim) {
-      return self.min(dim, keepdim);
+      return wrap(self.min(dim, keepdim));
     })
   .define_method(
     "_min_other",
@@ -1080,7 +1105,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_mode",
     *[](const Tensor &self, int64_t dim, bool keepdim) {
-      return self.mode(dim, keepdim);
+      return wrap(self.mode(dim, keepdim));
     })
   .define_method(
     "_mul__scalar",
@@ -1257,6 +1282,16 @@ void add_tensor_functions(Module m) {
     *[](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) {
@@ -1290,7 +1325,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_qr",
     *[](const Tensor &self, bool some) {
-      return self.qr(some);
+      return wrap(self.qr(some));
     })
   .define_method(
     "_qscheme",
@@ -1545,22 +1580,27 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_slogdet",
     *[](const Tensor &self) {
-      return self.slogdet();
+      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 self.solve(A);
+      return wrap(self.solve(A));
     })
   .define_method(
     "_sort",
     *[](const Tensor &self, int64_t dim, bool descending) {
-      return self.sort(dim, descending);
+      return wrap(self.sort(dim, descending));
     })
   .define_method(
     "_sparse_dim",
@@ -1662,6 +1702,16 @@ void add_tensor_functions(Module m) {
     *[](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) {
@@ -1670,12 +1720,12 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_svd",
     *[](const Tensor &self, bool some, bool compute_uv) {
-      return self.svd(some, compute_uv);
+      return wrap(self.svd(some, compute_uv));
     })
   .define_method(
     "_symeig",
     *[](const Tensor &self, bool eigenvectors, bool upper) {
-      return self.symeig(eigenvectors, upper);
+      return wrap(self.symeig(eigenvectors, upper));
     })
   .define_method(
     "_t",
@@ -1717,6 +1767,16 @@ void add_tensor_functions(Module m) {
     *[](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) {
@@ -1740,7 +1800,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_topk",
     *[](const Tensor &self, int64_t k, int64_t dim, bool largest, bool sorted) {
-      return self.topk(k, dim, largest, sorted);
+      return wrap(self.topk(k, dim, largest, sorted));
     })
   .define_method(
     "_trace",
@@ -1760,7 +1820,7 @@ void add_tensor_functions(Module m) {
   .define_method(
     "_triangular_solve",
     *[](const Tensor &self, const Tensor &A, bool upper, bool transpose, bool unitriangular) {
-      return self.triangular_solve(A, upper, transpose, unitriangular);
+      return wrap(self.triangular_solve(A, upper, transpose, unitriangular));
     })
   .define_method(
     "_tril",

data/ext/torch/torch_functions.cpp

@@ -45,7 +45,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_adaptive_max_pool1d",
     *[](const Tensor &self, IntArrayRef output_size) {
-      return torch::adaptive_max_pool1d(self, output_size);
+      return wrap(torch::adaptive_max_pool1d(self, output_size));
     })
   .define_singleton_method(
     "_add_out",
@@ -310,7 +310,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_batch_norm_backward_reduce",
     *[](const Tensor &grad_out, const Tensor &input, const Tensor &mean, const Tensor &invstd, OptionalTensor weight, bool input_g, bool weight_g, bool bias_g) {
-      return torch::batch_norm_backward_reduce(grad_out, input, mean, invstd, weight, input_g, weight_g, bias_g);
+      return wrap(torch::batch_norm_backward_reduce(grad_out, input, mean, invstd, weight, input_g, weight_g, bias_g));
     })
   .define_singleton_method(
     "_batch_norm_elemt",
@@ -320,22 +320,22 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_batch_norm_gather_stats",
     *[](const Tensor &input, const Tensor &mean, const Tensor &invstd, OptionalTensor running_mean, OptionalTensor running_var, double momentum, double eps, int64_t count) {
-      return torch::batch_norm_gather_stats(input, mean, invstd, running_mean, running_var, momentum, eps, count);
+      return wrap(torch::batch_norm_gather_stats(input, mean, invstd, running_mean, running_var, momentum, eps, count));
     })
   .define_singleton_method(
     "_batch_norm_gather_stats_with_counts",
     *[](const Tensor &input, const Tensor &mean, const Tensor &invstd, OptionalTensor running_mean, OptionalTensor running_var, double momentum, double eps, IntArrayRef counts) {
-      return torch::batch_norm_gather_stats_with_counts(input, mean, invstd, running_mean, running_var, momentum, eps, counts);
+      return wrap(torch::batch_norm_gather_stats_with_counts(input, mean, invstd, running_mean, running_var, momentum, eps, counts));
     })
   .define_singleton_method(
     "_batch_norm_stats",
     *[](const Tensor &input, double eps) {
-      return torch::batch_norm_stats(input, eps);
+      return wrap(torch::batch_norm_stats(input, eps));
     })
   .define_singleton_method(
     "_batch_norm_update_stats",
     *[](const Tensor &input, OptionalTensor running_mean, OptionalTensor running_var, double momentum) {
-      return torch::batch_norm_update_stats(input, running_mean, running_var, momentum);
+      return wrap(torch::batch_norm_update_stats(input, running_mean, running_var, momentum));
     })
   .define_singleton_method(
     "_bernoulli",
@@ -392,6 +392,11 @@ void add_torch_functions(Module m) {
     *[](TensorList tensors) {
       return torch::broadcast_tensors(tensors);
     })
+  .define_singleton_method(
+    "_can_cast",
+    *[](ScalarType from, ScalarType to) {
+      return torch::can_cast(from, to);
+    })
   .define_singleton_method(
     "_cartesian_prod",
     *[](TensorList tensors) {
@@ -630,7 +635,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_cudnn_batch_norm",
     *[](const Tensor &input, const Tensor &weight, OptionalTensor bias, OptionalTensor running_mean, OptionalTensor running_var, bool training, double exponential_average_factor, double epsilon) {
-      return torch::cudnn_batch_norm(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon);
+      return wrap(torch::cudnn_batch_norm(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon));
     })
   .define_singleton_method(
     "_cudnn_convolution",
@@ -682,6 +687,26 @@ void add_torch_functions(Module m) {
     *[](const Tensor &self) {
       return torch::cudnn_is_acceptable(self);
     })
+  .define_singleton_method(
+    "_cumprod",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype) {
+      return torch::cumprod(self, dim, dtype);
+    })
+  .define_singleton_method(
+    "_cumprod_out",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype, Tensor &out) {
+      return torch::cumprod_out(out, self, dim, dtype);
+    })
+  .define_singleton_method(
+    "_cumsum",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype) {
+      return torch::cumsum(self, dim, dtype);
+    })
+  .define_singleton_method(
+    "_cumsum_out",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype, Tensor &out) {
+      return torch::cumsum_out(out, self, dim, dtype);
+    })
   .define_singleton_method(
     "_dequantize",
     *[](const Tensor &self) {
@@ -780,12 +805,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_eig",
     *[](const Tensor &self, bool eigenvectors) {
-      return torch::eig(self, eigenvectors);
+      return wrap(torch::eig(self, eigenvectors));
     })
   .define_singleton_method(
     "_eig_e",
     *[](const Tensor &self, bool eigenvectors, Tensor &e, Tensor &v) {
-      return torch::eig_out(e, v, self, eigenvectors);
+      return wrap(torch::eig_out(e, v, self, eigenvectors));
     })
   .define_singleton_method(
     "_embedding",
@@ -795,7 +820,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_embedding_bag",
     *[](const Tensor &weight, const Tensor &indices, const Tensor &offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, OptionalTensor per_sample_weights) {
-      return torch::embedding_bag(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights);
+      return wrap(torch::embedding_bag(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights));
     })
   .define_singleton_method(
     "_embedding_renorm_",
@@ -945,7 +970,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_fbgemm_linear_quantize_weight",
     *[](const Tensor &input) {
-      return torch::fbgemm_linear_quantize_weight(input);
+      return wrap(torch::fbgemm_linear_quantize_weight(input));
     })
   .define_singleton_method(
     "_fbgemm_pack_gemm_matrix_fp16",
@@ -1115,12 +1140,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_geqrf",
     *[](const Tensor &self) {
-      return torch::geqrf(self);
+      return wrap(torch::geqrf(self));
     })
   .define_singleton_method(
     "_geqrf_a",
     *[](const Tensor &self, Tensor &a, Tensor &tau) {
-      return torch::geqrf_out(a, tau, self);
+      return wrap(torch::geqrf_out(a, tau, self));
     })
   .define_singleton_method(
     "_ger",
@@ -1160,12 +1185,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_gru_data",
     *[](const Tensor &data, const Tensor &batch_sizes, const Tensor &hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
-      return torch::gru(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
+      return wrap(torch::gru(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional));
     })
   .define_singleton_method(
     "_gru_input",
     *[](const Tensor &input, const Tensor &hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
-      return torch::gru(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
+      return wrap(torch::gru(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first));
     })
   .define_singleton_method(
     "_gt_scalar",
@@ -1325,12 +1350,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_kthvalue",
     *[](const Tensor &self, int64_t k, int64_t dim, bool keepdim) {
-      return torch::kthvalue(self, k, dim, keepdim);
+      return wrap(torch::kthvalue(self, k, dim, keepdim));
     })
   .define_singleton_method(
     "_kthvalue_values",
     *[](const Tensor &self, int64_t k, int64_t dim, bool keepdim, Tensor &values, Tensor &indices) {
-      return torch::kthvalue_out(values, indices, self, k, dim, keepdim);
+      return wrap(torch::kthvalue_out(values, indices, self, k, dim, keepdim));
     })
   .define_singleton_method(
     "_layer_norm",
@@ -1452,6 +1477,11 @@ void add_torch_functions(Module m) {
     *[](const Tensor &self, Tensor &out) {
       return torch::log_out(out, self);
     })
+  .define_singleton_method(
+    "_log_softmax",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype) {
+      return torch::log_softmax(self, dim, dtype);
+    })
   .define_singleton_method(
     "_logdet",
     *[](const Tensor &self) {
@@ -1495,27 +1525,27 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_lstm_cell",
     *[](const Tensor &input, TensorList hx, const Tensor &w_ih, const Tensor &w_hh, OptionalTensor b_ih, OptionalTensor b_hh) {
-      return torch::lstm_cell(input, hx, w_ih, w_hh, b_ih, b_hh);
+      return wrap(torch::lstm_cell(input, hx, w_ih, w_hh, b_ih, b_hh));
     })
   .define_singleton_method(
     "_lstm_data",
     *[](const Tensor &data, const Tensor &batch_sizes, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
-      return torch::lstm(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
+      return wrap(torch::lstm(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional));
     })
   .define_singleton_method(
     "_lstm_input",
     *[](const Tensor &input, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
-      return torch::lstm(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
+      return wrap(torch::lstm(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first));
     })
   .define_singleton_method(
     "_lstsq",
     *[](const Tensor &self, const Tensor &A) {
-      return torch::lstsq(self, A);
+      return wrap(torch::lstsq(self, A));
     })
   .define_singleton_method(
     "_lstsq_x",
     *[](const Tensor &self, const Tensor &A, Tensor &X, Tensor &qr) {
-      return torch::lstsq_out(X, qr, self, A);
+      return wrap(torch::lstsq_out(X, qr, self, A));
     })
   .define_singleton_method(
     "_lt_scalar",
@@ -1610,12 +1640,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_max_dim",
     *[](const Tensor &self, int64_t dim, bool keepdim) {
-      return torch::max(self, dim, keepdim);
+      return wrap(torch::max(self, dim, keepdim));
     })
   .define_singleton_method(
     "_max_dim_max",
     *[](const Tensor &self, int64_t dim, bool keepdim, Tensor &max, Tensor &max_values) {
-      return torch::max_out(max, max_values, self, dim, keepdim);
+      return wrap(torch::max_out(max, max_values, self, dim, keepdim));
     })
   .define_singleton_method(
     "_max_other",
@@ -1635,7 +1665,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_max_pool1d_with_indices",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
-      return torch::max_pool1d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
+      return wrap(torch::max_pool1d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode));
     })
   .define_singleton_method(
     "_max_pool2d",
@@ -1652,6 +1682,21 @@ void add_torch_functions(Module m) {
     *[](const Tensor &self, IntArrayRef dim, bool keepdim) {
       return torch::max_values(self, dim, keepdim);
     })
+  .define_singleton_method(
+    "_mean",
+    *[](const Tensor &self, OptionalScalarType dtype) {
+      return torch::mean(self, dtype);
+    })
+  .define_singleton_method(
+    "_mean_dim",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim, OptionalScalarType dtype) {
+      return torch::mean(self, dim, keepdim, dtype);
+    })
+  .define_singleton_method(
+    "_mean_out",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim, OptionalScalarType dtype, Tensor &out) {
+      return torch::mean_out(out, self, dim, keepdim, dtype);
+    })
   .define_singleton_method(
     "_median",
     *[](const Tensor &self) {
@@ -1660,12 +1705,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_median_dim",
     *[](const Tensor &self, int64_t dim, bool keepdim) {
-      return torch::median(self, dim, keepdim);
+      return wrap(torch::median(self, dim, keepdim));
     })
   .define_singleton_method(
     "_median_dim_values",
     *[](const Tensor &self, int64_t dim, bool keepdim, Tensor &values, Tensor &indices) {
-      return torch::median_out(values, indices, self, dim, keepdim);
+      return wrap(torch::median_out(values, indices, self, dim, keepdim));
     })
   .define_singleton_method(
     "_meshgrid",
@@ -1680,12 +1725,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_min_dim",
     *[](const Tensor &self, int64_t dim, bool keepdim) {
-      return torch::min(self, dim, keepdim);
+      return wrap(torch::min(self, dim, keepdim));
     })
   .define_singleton_method(
     "_min_dim_min",
     *[](const Tensor &self, int64_t dim, bool keepdim, Tensor &min, Tensor &min_indices) {
-      return torch::min_out(min, min_indices, self, dim, keepdim);
+      return wrap(torch::min_out(min, min_indices, self, dim, keepdim));
     })
   .define_singleton_method(
     "_min_other",
@@ -1705,7 +1750,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_miopen_batch_norm",
     *[](const Tensor &input, const Tensor &weight, OptionalTensor bias, OptionalTensor running_mean, OptionalTensor running_var, bool training, double exponential_average_factor, double epsilon) {
-      return torch::miopen_batch_norm(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon);
+      return wrap(torch::miopen_batch_norm(input, weight, bias, running_mean, running_var, training, exponential_average_factor, epsilon));
     })
   .define_singleton_method(
     "_miopen_convolution",
@@ -1760,7 +1805,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_miopen_rnn",
     *[](const Tensor &input, TensorList weight, int64_t weight_stride0, const Tensor &hx, OptionalTensor cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, IntArrayRef batch_sizes, OptionalTensor dropout_state) {
-      return torch::miopen_rnn(input, weight, weight_stride0, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state);
+      return wrap(torch::miopen_rnn(input, weight, weight_stride0, hx, cx, mode, hidden_size, num_layers, batch_first, dropout, train, bidirectional, batch_sizes, dropout_state));
     })
   .define_singleton_method(
     "_mkldnn_adaptive_avg_pool2d",
@@ -1780,7 +1825,7 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_mkldnn_convolution_backward_weights",
     *[](IntArrayRef weight_size, const Tensor &grad_output, const Tensor &self, IntArrayRef padding, IntArrayRef stride, IntArrayRef dilation, int64_t groups, bool bias_defined) {
-      return torch::mkldnn_convolution_backward_weights(weight_size, grad_output, self, padding, stride, dilation, groups, bias_defined);
+      return wrap(torch::mkldnn_convolution_backward_weights(weight_size, grad_output, self, padding, stride, dilation, groups, bias_defined));
     })
   .define_singleton_method(
     "_mkldnn_max_pool2d",
@@ -1800,12 +1845,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_mode",
     *[](const Tensor &self, int64_t dim, bool keepdim) {
-      return torch::mode(self, dim, keepdim);
+      return wrap(torch::mode(self, dim, keepdim));
     })
   .define_singleton_method(
     "_mode_values",
     *[](const Tensor &self, int64_t dim, bool keepdim, Tensor &values, Tensor &indices) {
-      return torch::mode_out(values, indices, self, dim, keepdim);
+      return wrap(torch::mode_out(values, indices, self, dim, keepdim));
     })
   .define_singleton_method(
     "_mul_out",
@@ -1855,12 +1900,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_native_batch_norm",
     *[](const Tensor &input, OptionalTensor weight, OptionalTensor bias, OptionalTensor running_mean, OptionalTensor running_var, bool training, double momentum, double eps) {
-      return torch::native_batch_norm(input, weight, bias, running_mean, running_var, training, momentum, eps);
+      return wrap(torch::native_batch_norm(input, weight, bias, running_mean, running_var, training, momentum, eps));
     })
   .define_singleton_method(
     "_native_layer_norm",
     *[](const Tensor &input, OptionalTensor weight, OptionalTensor bias, int64_t M, int64_t N, double eps) {
-      return torch::native_layer_norm(input, weight, bias, M, N, eps);
+      return wrap(torch::native_layer_norm(input, weight, bias, M, N, eps));
     })
   .define_singleton_method(
     "_native_norm",
@@ -2057,6 +2102,26 @@ void add_torch_functions(Module m) {
     *[](const Tensor &self, const Tensor &weight) {
       return torch::prelu(self, weight);
     })
+  .define_singleton_method(
+    "_prod",
+    *[](const Tensor &self, OptionalScalarType dtype) {
+      return torch::prod(self, dtype);
+    })
+  .define_singleton_method(
+    "_prod_dim_int",
+    *[](const Tensor &self, int64_t dim, bool keepdim, OptionalScalarType dtype) {
+      return torch::prod(self, dim, keepdim, dtype);
+    })
+  .define_singleton_method(
+    "_prod_int_out",
+    *[](const Tensor &self, int64_t dim, bool keepdim, OptionalScalarType dtype, Tensor &out) {
+      return torch::prod_out(out, self, dim, keepdim, dtype);
+    })
+  .define_singleton_method(
+    "_promote_types",
+    *[](ScalarType type1, ScalarType type2) {
+      return torch::promote_types(type1, type2);
+    })
   .define_singleton_method(
     "_q_per_channel_axis",
     *[](const Tensor &self) {
@@ -2085,12 +2150,22 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_qr",
     *[](const Tensor &self, bool some) {
-      return torch::qr(self, some);
+      return wrap(torch::qr(self, some));
     })
   .define_singleton_method(
     "_qr_q",
     *[](const Tensor &self, bool some, Tensor &Q, Tensor &R) {
-      return torch::qr_out(Q, R, self, some);
+      return wrap(torch::qr_out(Q, R, self, some));
+    })
+  .define_singleton_method(
+    "_quantize_per_channel",
+    *[](const Tensor &self, const Tensor &scales, const Tensor &zero_points, int64_t axis, ScalarType dtype) {
+      return torch::quantize_per_channel(self, scales, zero_points, axis, dtype);
+    })
+  .define_singleton_method(
+    "_quantize_per_tensor",
+    *[](const Tensor &self, double scale, int64_t zero_point, ScalarType dtype) {
+      return torch::quantize_per_tensor(self, scale, zero_point, dtype);
     })
   .define_singleton_method(
     "_quantized_gru_cell",
@@ -2100,17 +2175,22 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_quantized_gru_data",
     *[](const Tensor &data, const Tensor &batch_sizes, const Tensor &hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
-      return torch::quantized_gru(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
+      return wrap(torch::quantized_gru(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional));
     })
   .define_singleton_method(
     "_quantized_gru_input",
     *[](const Tensor &input, const Tensor &hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
-      return torch::quantized_gru(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
+      return wrap(torch::quantized_gru(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first));
+    })
+  .define_singleton_method(
+    "_quantized_lstm",
+    *[](const Tensor &input, TensorList hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first, OptionalScalarType dtype, bool use_dynamic) {
+      return wrap(torch::quantized_lstm(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first, dtype, use_dynamic));
     })
   .define_singleton_method(
     "_quantized_lstm_cell",
     *[](const Tensor &input, TensorList hx, const Tensor &w_ih, const Tensor &w_hh, const Tensor &b_ih, const Tensor &b_hh, const Tensor &packed_ih, const Tensor &packed_hh, const Tensor &col_offsets_ih, const Tensor &col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) {
-      return torch::quantized_lstm_cell(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh);
+      return wrap(torch::quantized_lstm_cell(input, hx, w_ih, w_hh, b_ih, b_hh, packed_ih, packed_hh, col_offsets_ih, col_offsets_hh, scale_ih, scale_hh, zero_point_ih, zero_point_hh));
     })
   .define_singleton_method(
     "_quantized_max_pool2d",
@@ -2325,12 +2405,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_rnn_relu_data",
     *[](const Tensor &data, const Tensor &batch_sizes, const Tensor &hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
-      return torch::rnn_relu(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
+      return wrap(torch::rnn_relu(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional));
     })
   .define_singleton_method(
     "_rnn_relu_input",
     *[](const Tensor &input, const Tensor &hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
-      return torch::rnn_relu(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
+      return wrap(torch::rnn_relu(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first));
     })
   .define_singleton_method(
     "_rnn_tanh_cell",
@@ -2340,12 +2420,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_rnn_tanh_data",
     *[](const Tensor &data, const Tensor &batch_sizes, const Tensor &hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional) {
-      return torch::rnn_tanh(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional);
+      return wrap(torch::rnn_tanh(data, batch_sizes, hx, params, has_biases, num_layers, dropout, train, bidirectional));
     })
   .define_singleton_method(
     "_rnn_tanh_input",
     *[](const Tensor &input, const Tensor &hx, TensorList params, bool has_biases, int64_t num_layers, double dropout, bool train, bool bidirectional, bool batch_first) {
-      return torch::rnn_tanh(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first);
+      return wrap(torch::rnn_tanh(input, hx, params, has_biases, num_layers, dropout, train, bidirectional, batch_first));
     })
   .define_singleton_method(
     "_roll",
@@ -2505,32 +2585,37 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_slogdet",
     *[](const Tensor &self) {
-      return torch::slogdet(self);
+      return wrap(torch::slogdet(self));
     })
   .define_singleton_method(
     "_smm",
     *[](const Tensor &self, const Tensor &mat2) {
       return torch::smm(self, mat2);
     })
+  .define_singleton_method(
+    "_softmax",
+    *[](const Tensor &self, int64_t dim, OptionalScalarType dtype) {
+      return torch::softmax(self, dim, dtype);
+    })
   .define_singleton_method(
     "_solve",
     *[](const Tensor &self, const Tensor &A) {
-      return torch::solve(self, A);
+      return wrap(torch::solve(self, A));
     })
   .define_singleton_method(
     "_solve_solution",
     *[](const Tensor &self, const Tensor &A, Tensor &solution, Tensor &lu) {
-      return torch::solve_out(solution, lu, self, A);
+      return wrap(torch::solve_out(solution, lu, self, A));
     })
   .define_singleton_method(
     "_sort",
     *[](const Tensor &self, int64_t dim, bool descending) {
-      return torch::sort(self, dim, descending);
+      return wrap(torch::sort(self, dim, descending));
     })
   .define_singleton_method(
     "_sort_values",
     *[](const Tensor &self, int64_t dim, bool descending, Tensor &values, Tensor &indices) {
-      return torch::sort_out(values, indices, self, dim, descending);
+      return wrap(torch::sort_out(values, indices, self, dim, descending));
     })
   .define_singleton_method(
     "_split_tensor",
@@ -2600,12 +2685,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_std_mean",
     *[](const Tensor &self, bool unbiased) {
-      return torch::std_mean(self, unbiased);
+      return wrap(torch::std_mean(self, unbiased));
     })
   .define_singleton_method(
     "_std_mean_dim",
     *[](const Tensor &self, IntArrayRef dim, bool unbiased, bool keepdim) {
-      return torch::std_mean(self, dim, unbiased, keepdim);
+      return wrap(torch::std_mean(self, dim, unbiased, keepdim));
     })
   .define_singleton_method(
     "_std_out",
@@ -2632,25 +2717,40 @@ void add_torch_functions(Module m) {
     *[](const Tensor &self, const Tensor &other, Scalar alpha) {
       return torch::sub(self, other, alpha);
     })
+  .define_singleton_method(
+    "_sum",
+    *[](const Tensor &self, OptionalScalarType dtype) {
+      return torch::sum(self, dtype);
+    })
+  .define_singleton_method(
+    "_sum_dim_intlist",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim, OptionalScalarType dtype) {
+      return torch::sum(self, dim, keepdim, dtype);
+    })
+  .define_singleton_method(
+    "_sum_intlist_out",
+    *[](const Tensor &self, IntArrayRef dim, bool keepdim, OptionalScalarType dtype, Tensor &out) {
+      return torch::sum_out(out, self, dim, keepdim, dtype);
+    })
   .define_singleton_method(
     "_svd",
     *[](const Tensor &self, bool some, bool compute_uv) {
-      return torch::svd(self, some, compute_uv);
+      return wrap(torch::svd(self, some, compute_uv));
     })
   .define_singleton_method(
     "_svd_u",
     *[](const Tensor &self, bool some, bool compute_uv, Tensor &U, Tensor &S, Tensor &V) {
-      return torch::svd_out(U, S, V, self, some, compute_uv);
+      return wrap(torch::svd_out(U, S, V, self, some, compute_uv));
     })
   .define_singleton_method(
     "_symeig",
     *[](const Tensor &self, bool eigenvectors, bool upper) {
-      return torch::symeig(self, eigenvectors, upper);
+      return wrap(torch::symeig(self, eigenvectors, upper));
     })
   .define_singleton_method(
     "_symeig_e",
     *[](const Tensor &self, bool eigenvectors, bool upper, Tensor &e, Tensor &V) {
-      return torch::symeig_out(e, V, self, eigenvectors, upper);
+      return wrap(torch::symeig_out(e, V, self, eigenvectors, upper));
     })
   .define_singleton_method(
     "_t",
@@ -2720,12 +2820,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_topk",
     *[](const Tensor &self, int64_t k, int64_t dim, bool largest, bool sorted) {
-      return torch::topk(self, k, dim, largest, sorted);
+      return wrap(torch::topk(self, k, dim, largest, sorted));
     })
   .define_singleton_method(
     "_topk_values",
     *[](const Tensor &self, int64_t k, int64_t dim, bool largest, bool sorted, Tensor &values, Tensor &indices) {
-      return torch::topk_out(values, indices, self, k, dim, largest, sorted);
+      return wrap(torch::topk_out(values, indices, self, k, dim, largest, sorted));
     })
   .define_singleton_method(
     "_trace",
@@ -2750,12 +2850,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_triangular_solve",
     *[](const Tensor &self, const Tensor &A, bool upper, bool transpose, bool unitriangular) {
-      return torch::triangular_solve(self, A, upper, transpose, unitriangular);
+      return wrap(torch::triangular_solve(self, A, upper, transpose, unitriangular));
     })
   .define_singleton_method(
     "_triangular_solve_x",
     *[](const Tensor &self, const Tensor &A, bool upper, bool transpose, bool unitriangular, Tensor &X, Tensor &M) {
-      return torch::triangular_solve_out(X, M, self, A, upper, transpose, unitriangular);
+      return wrap(torch::triangular_solve_out(X, M, self, A, upper, transpose, unitriangular));
     })
   .define_singleton_method(
     "_tril",
@@ -2805,17 +2905,17 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_unique_consecutive",
     *[](const Tensor &self, bool return_inverse, bool return_counts) {
-      return torch::unique_consecutive(self, return_inverse, return_counts);
+      return wrap(torch::unique_consecutive(self, return_inverse, return_counts));
     })
   .define_singleton_method(
     "_unique_consecutive_dim",
     *[](const Tensor &self, bool return_inverse, bool return_counts, int64_t dim) {
-      return torch::unique_consecutive(self, return_inverse, return_counts, dim);
+      return wrap(torch::unique_consecutive(self, return_inverse, return_counts, dim));
     })
   .define_singleton_method(
     "_unique_dim",
     *[](const Tensor &self, int64_t dim, bool sorted, bool return_inverse, bool return_counts) {
-      return torch::unique_dim(self, dim, sorted, return_inverse, return_counts);
+      return wrap(torch::unique_dim(self, dim, sorted, return_inverse, return_counts));
     })
   .define_singleton_method(
     "_unsqueeze",
@@ -2835,12 +2935,12 @@ void add_torch_functions(Module m) {
   .define_singleton_method(
     "_var_mean",
     *[](const Tensor &self, bool unbiased) {
-      return torch::var_mean(self, unbiased);
+      return wrap(torch::var_mean(self, unbiased));
     })
   .define_singleton_method(
     "_var_mean_dim",
     *[](const Tensor &self, IntArrayRef dim, bool unbiased, bool keepdim) {
-      return torch::var_mean(self, dim, unbiased, keepdim);
+      return wrap(torch::var_mean(self, dim, unbiased, keepdim));
     })
   .define_singleton_method(
     "_var_out",