torch-rb 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b47306ed525e1a20d25cb8324d4658f750c18afa5704c9b7bafc215d8f568c1
-  data.tar.gz: dad6ddf955b111989b061e5af146006a32c83dc1ea1ca5005a6b6e34bc9a4892
+  metadata.gz: 9667f9d3256f5e2d39937f17ae8eb00449dd14f79bb01cd647800bd7ed972fc6
+  data.tar.gz: 54c23612c79355e09c97da5fcf6b97c183da8316d1c2a53d6f8f0463e98342a2
 SHA512:
-  metadata.gz: 5d26e3642bf7cd921b9b570052df353d4c32b1bd955a6fbbf5f30249631fa4c0d4624f4fa91a1c06f61b3b0d6461cd117ab4df185cf013e915d2f63e52dbcf7c
-  data.tar.gz: 1728ce9b579f41f7a567e63d7256c82bb352840b67f16d88aac930a99e5abbf5a5f4061c5f9da16fb47d1664567e7956d276a8b2b44f13d2263032486afb53e8
+  metadata.gz: bb2c8e5aae436367aeb871a2d19958e59ed9e9c7601b1b8b4473e33094cadf6d657947582b0ec93a29cb08723f8f7c81178a2d50beb23a125d5a356769d92177
+  data.tar.gz: 62feef39da31a19415e2e6c453aed4972e34db7367161a088944c06a977637a8b25cecc8eb2ad052b3b9deee0707f364e616cc33e7674cf0314899421f18fbee

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.1.6 (2019-12-09)
+
+- Added recurrent layers
+- Added more pooling layers
+- Added normalization layers
+
 ## 0.1.5 (2019-12-06)
 
 - Added many more functions

data/README.md

@@ -369,7 +369,7 @@ Here are a few full examples:
 
 - [Image classification with MNIST](examples/mnist) ([日本語版](https://qiita.com/kojix2/items/c19c36dc1bf73ea93409))
 - [Collaborative filtering with MovieLens](examples/movielens)
-- [Word embeddings](examples/nlp)
+- [Sequence models and word embeddings](examples/nlp)
 
 ## LibTorch Installation
 

data/ext/torch/ext.cpp

@@ -16,13 +16,6 @@
 
 using namespace Rice;
 
-Object tensor_array(std::tuple<torch::Tensor, torch::Tensor> x) {
-  Array a;
-  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
-  return Object(a);
-}
-
 extern "C"
 void Init_ext()
 {
@@ -112,94 +105,11 @@ void Init_ext()
         return torch::zeros(size, options);
       })
     // begin operations
-    .define_singleton_method(
-      "_mean",
-      *[](Tensor& input) {
-        return torch::mean(input);
-      })
-    .define_singleton_method(
-      "_mean_dim",
-      *[](Tensor& input, int64_t dim, bool keepdim) {
-        return torch::mean(input, dim, keepdim);
-      })
-    .define_singleton_method(
-      "_sum",
-      *[](Tensor& input) {
-        return torch::sum(input);
-      })
-    .define_singleton_method(
-      "_sum_dim",
-      *[](Tensor& input, int64_t dim, bool keepdim) {
-        return torch::sum(input, dim, keepdim);
-      })
-    .define_singleton_method(
-      "_max_out",
-      *[](Tensor &max, Tensor &max_indices, const Tensor &input, int64_t dim, bool keepdim) {
-        return tensor_array(torch::_max_out(max, max_indices, input, dim, keepdim));
-      })
-    .define_singleton_method(
-      "_topk",
-      *[](Tensor& input, int64_t k) {
-        return tensor_array(torch::topk(input, k));
-      })
-    .define_singleton_method(
-      "_softmax",
-      *[](const Tensor &input, int64_t dim) {
-        return torch::softmax(input, dim);
-      })
-    .define_singleton_method(
-      "_log_softmax",
-      *[](Tensor& input, int64_t dim) {
-        return torch::log_softmax(input, dim);
-      })
-    .define_singleton_method(
-      "relu",
-      *[](Tensor& input) {
-        return torch::relu(input);
-      })
-    .define_singleton_method(
-      "prelu",
-      *[](torch::Tensor& input, torch::Tensor& weight) {
-        return torch::prelu(input, weight);
-      })
-    .define_singleton_method(
-      "leaky_relu",
-      *[](torch::Tensor& input, Scalar negative_slope) {
-        return torch::leaky_relu(input, negative_slope);
-      })
-    .define_singleton_method(
-      "conv2d",
-      *[](Tensor& input, Tensor& weight, Tensor& bias, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, int64_t groups) {
-        return torch::conv2d(input, weight, bias, stride, padding, dilation, groups);
-      })
-    // linear layers
-    .define_singleton_method(
-      "bilinear",
-      *[](const Tensor &input1, const Tensor &input2, const Tensor &weight, const Tensor &bias) {
-        return torch::bilinear(input1, input2, weight, bias);
-      })
-    .define_singleton_method(
-      "linear",
-      *[](Tensor& input, Tensor& weight, Tensor& bias) {
-        return torch::linear(input, weight, bias);
-      })
-    // pooling layers
-    .define_singleton_method(
-      "max_pool2d",
-      *[](Tensor& input, IntArrayRef kernel_size) {
-        return torch::max_pool2d(input, kernel_size);
-      })
-    .define_singleton_method(
-      "avg_pool2d",
-      *[](Tensor& input, IntArrayRef kernel_size) {
-        return torch::avg_pool2d(input, kernel_size);
-      })
     .define_singleton_method(
       "_binary_cross_entropy_with_logits",
       *[](const Tensor &input, const Tensor &target, OptionalTensor weight, OptionalTensor pos_weight, MyReduction reduction) {
         return torch::binary_cross_entropy_with_logits(input, target, weight, pos_weight, reduction);
       })
-    .define_singleton_method("numel", &torch::numel)
     .define_singleton_method(
       "_from_blob",
       *[](String s, IntArrayRef size, const torch::TensorOptions &options) {
@@ -226,16 +136,11 @@ void Init_ext()
 
   rb_cTensor
     .define_method("cuda?", &torch::Tensor::is_cuda)
-    .define_method("distributed?", &torch::Tensor::is_distributed)
-    .define_method("complex?", &torch::Tensor::is_complex)
-    .define_method("floating_point?", &torch::Tensor::is_floating_point)
-    .define_method("signed?", &torch::Tensor::is_signed)
     .define_method("sparse?", &torch::Tensor::is_sparse)
     .define_method("quantized?", &torch::Tensor::is_quantized)
     .define_method("dim", &torch::Tensor::dim)
     .define_method("element_size", &torch::Tensor::element_size)
     .define_method("requires_grad", &torch::Tensor::requires_grad)
-    .define_method("view_as", &torch::Tensor::view_as)
     .define_method(
       "addcmul!",
       *[](Tensor& self, Scalar value, const Tensor & tensor1, const Tensor & tensor2) {
@@ -246,21 +151,6 @@ void Init_ext()
       *[](Tensor& self, Scalar value, const Tensor & tensor1, const Tensor & tensor2) {
         return self.addcdiv_(tensor1, tensor2, value);
       })
-    .define_method(
-      "zero!",
-      *[](Tensor& self) {
-        return self.zero_();
-      })
-    .define_method(
-      "detach",
-      *[](Tensor& self) {
-        return self.detach();
-      })
-    .define_method(
-      "detach!",
-      *[](Tensor& self) {
-        return self.detach_();
-      })
     .define_method(
       "_requires_grad!",
       *[](Tensor& self, bool requires_grad) {
@@ -300,66 +190,6 @@ void Init_ext()
         s << self.device();
         return s.str();
       })
-    .define_method(
-      "resize_as!",
-      *[](Tensor& self, Tensor& other) {
-        return self.resize_as_(other);
-      })
-    .define_method(
-      "fill!",
-      *[](Tensor& self, Scalar value) {
-        return self.fill_(value);
-      })
-    .define_method(
-      "relu!",
-      *[](Tensor& self) {
-        return self.relu_();
-      })
-    .define_method(
-      "normal!",
-      *[](Tensor& self, double mean, double std) {
-        return self.normal_(mean, std);
-      })
-    .define_method(
-      "random!",
-      *[](Tensor& self, int64_t to) {
-        return self.random_(to);
-      })
-    .define_method(
-      "sub!",
-      *[](Tensor& self, Tensor& other) {
-        return self.sub_(other);
-      })
-    .define_method(
-      "div!",
-      *[](Tensor& self, Tensor& other) {
-        return self.div_(other);
-      })
-    .define_method(
-      "sqrt!",
-      *[](Tensor& self) {
-        return self.sqrt_();
-      })
-    .define_method(
-      "unsqueeze!",
-      *[](Tensor& self, int64_t dim) {
-        return self.unsqueeze_(dim);
-      })
-    .define_method(
-      "copy!",
-      *[](Tensor& self, Tensor& src) {
-        return self.copy_(src);
-      })
-    .define_method(
-      "clone",
-      *[](Tensor& self) {
-        return self.clone();
-      })
-    .define_method(
-      "data",
-      *[](Tensor& self) {
-        return self.data();
-      })
     .define_method(
       "_flat_data",
       *[](Tensor& self) {

data/ext/torch/nn_functions.cpp

@@ -30,22 +30,42 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_adaptive_max_pool2d",
     *[](const Tensor &self, IntArrayRef output_size) {
-      return torch::adaptive_max_pool2d(self, output_size);
+      return wrap(torch::adaptive_max_pool2d(self, output_size));
     })
   .define_singleton_method(
     "_adaptive_max_pool2d_out",
     *[](const Tensor &self, IntArrayRef output_size, Tensor &out, Tensor &indices) {
-      return torch::adaptive_max_pool2d_out(out, indices, self, output_size);
+      return wrap(torch::adaptive_max_pool2d_out(out, indices, self, output_size));
     })
   .define_singleton_method(
     "_adaptive_max_pool3d",
     *[](const Tensor &self, IntArrayRef output_size) {
-      return torch::adaptive_max_pool3d(self, output_size);
+      return wrap(torch::adaptive_max_pool3d(self, output_size));
     })
   .define_singleton_method(
     "_adaptive_max_pool3d_out",
     *[](const Tensor &self, IntArrayRef output_size, Tensor &out, Tensor &indices) {
-      return torch::adaptive_max_pool3d_out(out, indices, self, output_size);
+      return wrap(torch::adaptive_max_pool3d_out(out, indices, self, output_size));
+    })
+  .define_singleton_method(
+    "_avg_pool2d",
+    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad) {
+      return torch::avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
+    })
+  .define_singleton_method(
+    "_avg_pool2d_divisor_override",
+    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, int64_t divisor_override) {
+      return torch::avg_pool2d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
+    })
+  .define_singleton_method(
+    "_avg_pool3d",
+    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad) {
+      return torch::avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad);
+    })
+  .define_singleton_method(
+    "_avg_pool3d_divisor_override",
+    *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, bool ceil_mode, bool count_include_pad, int64_t divisor_override) {
+      return torch::avg_pool3d(self, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
     })
   .define_singleton_method(
     "_binary_cross_entropy",
@@ -85,22 +105,22 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_fractional_max_pool2d",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor &random_samples) {
-      return torch::fractional_max_pool2d(self, kernel_size, output_size, random_samples);
+      return wrap(torch::fractional_max_pool2d(self, kernel_size, output_size, random_samples));
     })
   .define_singleton_method(
     "_fractional_max_pool2d_output",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor &random_samples, Tensor &output, Tensor &indices) {
-      return torch::fractional_max_pool2d_out(output, indices, self, kernel_size, output_size, random_samples);
+      return wrap(torch::fractional_max_pool2d_out(output, indices, self, kernel_size, output_size, random_samples));
     })
   .define_singleton_method(
     "_fractional_max_pool3d",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor &random_samples) {
-      return torch::fractional_max_pool3d(self, kernel_size, output_size, random_samples);
+      return wrap(torch::fractional_max_pool3d(self, kernel_size, output_size, random_samples));
     })
   .define_singleton_method(
     "_fractional_max_pool3d_output",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef output_size, const Tensor &random_samples, Tensor &output, Tensor &indices) {
-      return torch::fractional_max_pool3d_out(output, indices, self, kernel_size, output_size, random_samples);
+      return wrap(torch::fractional_max_pool3d_out(output, indices, self, kernel_size, output_size, random_samples));
     })
   .define_singleton_method(
     "_gelu",
@@ -180,12 +200,12 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_log_sigmoid_forward",
     *[](const Tensor &self) {
-      return torch::log_sigmoid_forward(self);
+      return wrap(torch::log_sigmoid_forward(self));
     })
   .define_singleton_method(
     "_log_sigmoid_forward_output",
     *[](const Tensor &self, Tensor &output, Tensor &buffer) {
-      return torch::log_sigmoid_forward_out(output, buffer, self);
+      return wrap(torch::log_sigmoid_forward_out(output, buffer, self));
     })
   .define_singleton_method(
     "_log_sigmoid_out",
@@ -195,22 +215,22 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_max_pool2d_with_indices",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
-      return torch::max_pool2d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
+      return wrap(torch::max_pool2d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode));
     })
   .define_singleton_method(
     "_max_pool2d_with_indices_out",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, Tensor &out, Tensor &indices) {
-      return torch::max_pool2d_with_indices_out(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
+      return wrap(torch::max_pool2d_with_indices_out(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode));
     })
   .define_singleton_method(
     "_max_pool3d_with_indices",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode) {
-      return torch::max_pool3d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode);
+      return wrap(torch::max_pool3d_with_indices(self, kernel_size, stride, padding, dilation, ceil_mode));
     })
   .define_singleton_method(
     "_max_pool3d_with_indices_out",
     *[](const Tensor &self, IntArrayRef kernel_size, IntArrayRef stride, IntArrayRef padding, IntArrayRef dilation, bool ceil_mode, Tensor &out, Tensor &indices) {
-      return torch::max_pool3d_with_indices_out(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode);
+      return wrap(torch::max_pool3d_with_indices_out(out, indices, self, kernel_size, stride, padding, dilation, ceil_mode));
     })
   .define_singleton_method(
     "_max_unpool2d",
@@ -270,12 +290,12 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_multilabel_margin_loss_forward",
     *[](const Tensor &self, const Tensor &target, MyReduction reduction) {
-      return torch::multilabel_margin_loss_forward(self, target, reduction);
+      return wrap(torch::multilabel_margin_loss_forward(self, target, reduction));
     })
   .define_singleton_method(
     "_multilabel_margin_loss_forward_output",
     *[](const Tensor &self, const Tensor &target, MyReduction reduction, Tensor &output, Tensor &is_target) {
-      return torch::multilabel_margin_loss_forward_out(output, is_target, self, target, reduction);
+      return wrap(torch::multilabel_margin_loss_forward_out(output, is_target, self, target, reduction));
     })
   .define_singleton_method(
     "_multilabel_margin_loss_out",
@@ -295,12 +315,12 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_nll_loss2d_forward",
     *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index) {
-      return torch::nll_loss2d_forward(self, target, weight, reduction, ignore_index);
+      return wrap(torch::nll_loss2d_forward(self, target, weight, reduction, ignore_index));
     })
   .define_singleton_method(
     "_nll_loss2d_forward_output",
     *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index, Tensor &output, Tensor &total_weight) {
-      return torch::nll_loss2d_forward_out(output, total_weight, self, target, weight, reduction, ignore_index);
+      return wrap(torch::nll_loss2d_forward_out(output, total_weight, self, target, weight, reduction, ignore_index));
     })
   .define_singleton_method(
     "_nll_loss2d_out",
@@ -310,12 +330,12 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_nll_loss_forward",
     *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index) {
-      return torch::nll_loss_forward(self, target, weight, reduction, ignore_index);
+      return wrap(torch::nll_loss_forward(self, target, weight, reduction, ignore_index));
     })
   .define_singleton_method(
     "_nll_loss_forward_output",
     *[](const Tensor &self, const Tensor &target, OptionalTensor weight, MyReduction reduction, int64_t ignore_index, Tensor &output, Tensor &total_weight) {
-      return torch::nll_loss_forward_out(output, total_weight, self, target, weight, reduction, ignore_index);
+      return wrap(torch::nll_loss_forward_out(output, total_weight, self, target, weight, reduction, ignore_index));
     })
   .define_singleton_method(
     "_nll_loss_out",
@@ -470,12 +490,12 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_thnn_conv2d_forward",
     *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding) {
-      return torch::thnn_conv2d_forward(self, weight, kernel_size, bias, stride, padding);
+      return wrap(torch::thnn_conv2d_forward(self, weight, kernel_size, bias, stride, padding));
     })
   .define_singleton_method(
     "_thnn_conv2d_forward_output",
     *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, Tensor &output, Tensor &finput, Tensor &fgrad_input) {
-      return torch::thnn_conv2d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
+      return wrap(torch::thnn_conv2d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding));
     })
   .define_singleton_method(
     "_thnn_conv2d_out",
@@ -490,12 +510,12 @@ void add_nn_functions(Module m) {
   .define_singleton_method(
     "_thnn_conv3d_forward",
     *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding) {
-      return torch::thnn_conv3d_forward(self, weight, kernel_size, bias, stride, padding);
+      return wrap(torch::thnn_conv3d_forward(self, weight, kernel_size, bias, stride, padding));
     })
   .define_singleton_method(
     "_thnn_conv3d_forward_output",
     *[](const Tensor &self, const Tensor &weight, IntArrayRef kernel_size, OptionalTensor bias, IntArrayRef stride, IntArrayRef padding, Tensor &output, Tensor &finput, Tensor &fgrad_input) {
-      return torch::thnn_conv3d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding);
+      return wrap(torch::thnn_conv3d_forward_out(output, finput, fgrad_input, self, weight, kernel_size, bias, stride, padding));
     })
   .define_singleton_method(
     "_thnn_conv3d_out",

data/ext/torch/templates.cpp

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