torch-rb 0.3.2 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97908e85a67729120f763bb4140323505b77a831d5648e9d2d0961259e3d300c
-  data.tar.gz: f366548f9880dac7dffce6305e192f75a7467526ae55ae13af05d355918375ba
+  metadata.gz: 8a1852ee3d1ecc7a29c23259b8c328a95030a270b7c11f37f22049177898652e
+  data.tar.gz: 56823f1815d3c0c4d5d5c01ef76d781b792b3e4e7c68c0332a149b883a54c7c8
 SHA512:
-  metadata.gz: cc32ddbc43131175452a8b62df5d1eac6bc8450eea174018affd5cd073f81e2c9825d613014c62c5f8137cf5dddd1ab6ab6de60a4b3a67a757387446dbc1efad
-  data.tar.gz: c322e0b7ec7f03f12311d737034dad45037d2ad7710974e24250e11f4a0db14e221e870ddc52c0f2b723476be6f41fca8a8719068b0d0b7d8974d2080e9be6dc
+  metadata.gz: bed15510cfeaa555d71f1e1f46ed8944893bd349a07c4316dcd63429fe76e13facd8794399ef97fc400d05796579f2e84822b62c98c71dc996e211ad04113ae2
+  data.tar.gz: aa05e3645e363eda27274323cdb7fb316342074d1d5afe8f7ee6bfd9819da7883b43d084beb6b29011c631c04fdddc8e6789db41c7c84c53ba9ed152d3338b09

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 0.3.7 (2020-09-22)
+
+- Improved performance
+- Added `Upsample`
+- Added support for passing tensor class to `type` method
+- Fixed error with buffers on GPU
+- Fixed error with `new_full`
+- Fixed issue with `numo` method and non-contiguous tensors
+
+## 0.3.6 (2020-09-17)
+
+- Added `inplace` option for leaky ReLU
+- Fixed error with methods that return a tensor list (`chunk`, `split`, and `unbind`)
+- Fixed error with buffers on GPU
+
+## 0.3.5 (2020-09-04)
+
+- Fixed error with data loader (due to `dtype` of `randperm`)
+
+## 0.3.4 (2020-08-26)
+
+- Added `Torch.clamp` method
+
+## 0.3.3 (2020-08-25)
+
+- Added spectral ops
+- Fixed tensor indexing
+
 ## 0.3.2 (2020-08-24)
 
 - Added `enable_grad` method

data/README.md

@@ -2,7 +2,11 @@
 
 :fire: Deep learning for Ruby, powered by [LibTorch](https://pytorch.org)
 
-For computer vision tasks, also check out [TorchVision](https://github.com/ankane/torchvision)
+Check out:
+
+- [TorchVision](https://github.com/ankane/torchvision) for computer vision tasks
+- [TorchText](https://github.com/ankane/torchtext) for text and NLP tasks
+- [TorchAudio](https://github.com/ankane/torchaudio) for audio tasks
 
 [![Build Status](https://travis-ci.org/ankane/torch.rb.svg?branch=master)](https://travis-ci.org/ankane/torch.rb)
 
@@ -398,6 +402,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)
 - [Sequence models and word embeddings](examples/nlp)
+- [Generative adversarial networks](examples/gan)
 
 ## LibTorch Installation
 
@@ -411,7 +416,7 @@ Here’s the list of compatible versions.
 
 Torch.rb | LibTorch
 --- | ---
-0.3.0-0.3.1 | 1.6.0
+0.3.0-0.3.4 | 1.6.0
 0.2.0-0.2.7 | 1.5.0-1.5.1
 0.1.8 | 1.4.0
 0.1.0-0.1.7 | 1.3.1

data/ext/torch/ext.cpp

@@ -16,6 +16,7 @@
 #include "nn_functions.hpp"
 
 using namespace Rice;
+using torch::indexing::TensorIndex;
 
 // need to make a distinction between parameters and tensors
 class Parameter: public torch::autograd::Variable {
@@ -28,6 +29,15 @@ void handle_error(torch::Error const & ex)
   throw Exception(rb_eRuntimeError, ex.what_without_backtrace());
 }
 
+std::vector<TensorIndex> index_vector(Array a) {
+  auto indices = std::vector<TensorIndex>();
+  indices.reserve(a.size());
+  for (size_t i = 0; i < a.size(); i++) {
+    indices.push_back(from_ruby<TensorIndex>(a[i]));
+  }
+  return indices;
+}
+
 extern "C"
 void Init_ext()
 {
@@ -58,6 +68,13 @@ void Init_ext()
         return generator.seed();
       });
 
+  Class rb_cTensorIndex = define_class_under<TensorIndex>(rb_mTorch, "TensorIndex")
+    .define_singleton_method("boolean", *[](bool value) { return TensorIndex(value); })
+    .define_singleton_method("integer", *[](int64_t value) { return TensorIndex(value); })
+    .define_singleton_method("tensor", *[](torch::Tensor& value) { return TensorIndex(value); })
+    .define_singleton_method("slice", *[](torch::optional<int64_t> start_index, torch::optional<int64_t> stop_index) { return TensorIndex(torch::indexing::Slice(start_index, stop_index)); })
+    .define_singleton_method("none", *[]() { return TensorIndex(torch::indexing::None); });
+
   // https://pytorch.org/cppdocs/api/structc10_1_1_i_value.html
   Class rb_cIValue = define_class_under<torch::IValue>(rb_mTorch, "IValue")
     .add_handler<torch::Error>(handle_error)
@@ -215,7 +232,7 @@ void Init_ext()
       })
     .define_singleton_method(
       "_empty",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::empty(size, options);
       })
     .define_singleton_method(
@@ -225,7 +242,7 @@ void Init_ext()
       })
     .define_singleton_method(
       "_full",
-      *[](IntArrayRef size, Scalar fill_value, const torch::TensorOptions& options) {
+      *[](std::vector<int64_t> size, Scalar fill_value, const torch::TensorOptions& options) {
         return torch::full(size, fill_value, options);
       })
     .define_singleton_method(
@@ -240,22 +257,22 @@ void Init_ext()
       })
     .define_singleton_method(
       "_ones",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::ones(size, options);
       })
     .define_singleton_method(
       "_rand",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::rand(size, options);
       })
     .define_singleton_method(
       "_randint",
-      *[](int64_t low, int64_t high, IntArrayRef size, const torch::TensorOptions &options) {
+      *[](int64_t low, int64_t high, std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::randint(low, high, size, options);
       })
     .define_singleton_method(
       "_randn",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::randn(size, options);
       })
     .define_singleton_method(
@@ -265,7 +282,7 @@ void Init_ext()
       })
     .define_singleton_method(
       "_zeros",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::zeros(size, options);
       })
     // begin operations
@@ -284,20 +301,15 @@ void Init_ext()
         // https://github.com/pytorch/pytorch/issues/20356#issuecomment-567663701
         return torch::pickle_load(v);
       })
-    .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(
       "_from_blob",
-      *[](String s, IntArrayRef size, const torch::TensorOptions &options) {
+      *[](String s, std::vector<int64_t> size, const torch::TensorOptions &options) {
         void *data = const_cast<char *>(s.c_str());
         return torch::from_blob(data, size, options);
       })
     .define_singleton_method(
       "_tensor",
-      *[](Array a, IntArrayRef size, const torch::TensorOptions &options) {
+      *[](Array a, std::vector<int64_t> size, const torch::TensorOptions &options) {
         auto dtype = options.dtype();
         torch::Tensor t;
         if (dtype == torch::kBool) {
@@ -330,6 +342,28 @@ void Init_ext()
     .define_method("numel", &torch::Tensor::numel)
     .define_method("element_size", &torch::Tensor::element_size)
     .define_method("requires_grad", &torch::Tensor::requires_grad)
+    // in C++ for performance
+    .define_method(
+      "shape",
+      *[](Tensor& self) {
+        Array a;
+        for (auto &size : self.sizes()) {
+          a.push(size);
+        }
+        return a;
+      })
+    .define_method(
+      "_index",
+      *[](Tensor& self, Array indices) {
+        auto vec = index_vector(indices);
+        return self.index(vec);
+      })
+    .define_method(
+      "_index_put_custom",
+      *[](Tensor& self, Array indices, torch::Tensor& value) {
+        auto vec = index_vector(indices);
+        return self.index_put_(vec, value);
+      })
     .define_method(
       "contiguous?",
       *[](Tensor& self) {
@@ -350,11 +384,6 @@ void Init_ext()
       *[](Tensor& self, bool requires_grad) {
         return self.set_requires_grad(requires_grad);
       })
-    .define_method(
-      "_backward",
-      *[](Tensor& self, OptionalTensor gradient, bool create_graph, bool retain_graph) {
-        return self.backward(gradient, create_graph, retain_graph);
-      })
     .define_method(
       "grad",
       *[](Tensor& self) {
@@ -401,9 +430,19 @@ void Init_ext()
           tensor = tensor.to(device);
         }
 
+        if (!tensor.is_contiguous()) {
+          tensor = tensor.contiguous();
+        }
+
         auto data_ptr = (const char *) tensor.data_ptr();
         return std::string(data_ptr, tensor.numel() * tensor.element_size());
       })
+    // for TorchVision
+    .define_method(
+      "_data_ptr",
+      *[](Tensor& self) {
+        return reinterpret_cast<uintptr_t>(self.data_ptr());
+      })
     // TODO figure out a better way to do this
     .define_method(
       "_flat_data",
@@ -508,6 +547,7 @@ void Init_ext()
       });
 
   Module rb_mInit = define_module_under(rb_mNN, "Init")
+    .add_handler<torch::Error>(handle_error)
     .define_singleton_method(
       "_calculate_gain",
       *[](NonlinearityType nonlinearity, double param) {
@@ -594,8 +634,8 @@ void Init_ext()
       });
 
   Class rb_cDevice = define_class_under<torch::Device>(rb_mTorch, "Device")
-    .define_constructor(Constructor<torch::Device, std::string>())
     .add_handler<torch::Error>(handle_error)
+    .define_constructor(Constructor<torch::Device, std::string>())
     .define_method("index", &torch::Device::index)
     .define_method("index?", &torch::Device::has_index)
     .define_method(

data/ext/torch/extconf.rb

@@ -17,6 +17,9 @@ if have_library("omp") || have_library("gomp")
 end
 
 if apple_clang
+  # silence rice warnings
+  $CXXFLAGS += " -Wno-deprecated-declarations"
+
   # silence ruby/intern.h warning
   $CXXFLAGS += " -Wno-deprecated-register"
 

data/ext/torch/templates.cpp

@@ -2,6 +2,34 @@
 #include <rice/Object.hpp>
 #include "templates.hpp"
 
+Object wrap(bool x) {
+  return to_ruby<bool>(x);
+}
+
+Object wrap(int64_t x) {
+  return to_ruby<int64_t>(x);
+}
+
+Object wrap(double x) {
+  return to_ruby<double>(x);
+}
+
+Object wrap(torch::Tensor x) {
+  return to_ruby<torch::Tensor>(x);
+}
+
+Object wrap(torch::Scalar x) {
+  return to_ruby<torch::Scalar>(x);
+}
+
+Object wrap(torch::ScalarType x) {
+  return to_ruby<torch::ScalarType>(x);
+}
+
+Object wrap(torch::QScheme x) {
+  return to_ruby<torch::QScheme>(x);
+}
+
 Object wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
   Array a;
   a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
@@ -53,3 +81,11 @@ Object wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
   a.push(to_ruby<int64_t>(std::get<3>(x)));
   return Object(a);
 }
+
+Object wrap(std::vector<torch::Tensor> x) {
+  Array a;
+  for (auto& t : x) {
+    a.push(to_ruby<torch::Tensor>(t));
+  }
+  return Object(a);
+}

data/ext/torch/templates.hpp

@@ -9,72 +9,35 @@
 
 using namespace Rice;
 
-// need to wrap torch::IntArrayRef() since
-// it doesn't own underlying data
-class IntArrayRef {
-  std::vector<int64_t> vec;
-  public:
-    IntArrayRef(Object o) {
-      Array a = Array(o);
-      for (size_t i = 0; i < a.size(); i++) {
-        vec.push_back(from_ruby<int64_t>(a[i]));
-      }
-    }
-    operator torch::IntArrayRef() {
-      return torch::IntArrayRef(vec);
-    }
-};
+using torch::Device;
+using torch::Scalar;
+using torch::ScalarType;
+using torch::Tensor;
+using torch::IntArrayRef;
+using torch::TensorList;
 
 template<>
 inline
-IntArrayRef from_ruby<IntArrayRef>(Object x)
+std::vector<int64_t> from_ruby<std::vector<int64_t>>(Object x)
 {
-  return IntArrayRef(x);
+  Array a = Array(x);
+  std::vector<int64_t> vec(a.size());
+  for (size_t i = 0; i < a.size(); i++) {
+    vec[i] = from_ruby<int64_t>(a[i]);
+  }
+  return vec;
 }
 
-// for now
-class Scalar {
-  torch::Scalar value;
-  public:
-    Scalar(Object o) {
-      // TODO cast based on Ruby type
-      if (o.rb_type() == T_FIXNUM) {
-        value = torch::Scalar(from_ruby<int64_t>(o));
-      } else {
-        value = torch::Scalar(from_ruby<float>(o));
-      }
-    }
-    operator torch::Scalar() {
-      return value;
-    }
-};
-
 template<>
 inline
-Scalar from_ruby<Scalar>(Object x)
+std::vector<Tensor> from_ruby<std::vector<Tensor>>(Object x)
 {
-  return Scalar(x);
-}
-
-class TensorList {
-  std::vector<torch::Tensor> vec;
-  public:
-    TensorList(Object o) {
-      Array a = Array(o);
-      for (size_t i = 0; i < a.size(); i++) {
-        vec.push_back(from_ruby<torch::Tensor>(a[i]));
-      }
-    }
-    operator torch::TensorList() {
-      return torch::TensorList(vec);
-    }
-};
-
-template<>
-inline
-TensorList from_ruby<TensorList>(Object x)
-{
-  return TensorList(x);
+  Array a = Array(x);
+  std::vector<Tensor> vec(a.size());
+  for (size_t i = 0; i < a.size(); i++) {
+    vec[i] = from_ruby<Tensor>(a[i]);
+  }
+  return vec;
 }
 
 class FanModeType {
@@ -174,8 +137,6 @@ MyReduction from_ruby<MyReduction>(Object x)
   return MyReduction(x);
 }
 
-typedef torch::Tensor Tensor;
-
 class OptionalTensor {
   Object value;
   public:
@@ -190,6 +151,17 @@ class OptionalTensor {
     }
 };
 
+template<>
+inline
+Scalar from_ruby<Scalar>(Object x)
+{
+  if (x.rb_type() == T_FIXNUM) {
+    return torch::Scalar(from_ruby<int64_t>(x));
+  } else {
+    return torch::Scalar(from_ruby<double>(x));
+  }
+}
+
 template<>
 inline
 OptionalTensor from_ruby<OptionalTensor>(Object x)
@@ -197,50 +169,72 @@ 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
+torch::optional<torch::ScalarType> from_ruby<torch::optional<torch::ScalarType>>(Object x)
+{
+  if (x.is_nil()) {
+    return torch::nullopt;
+  } else {
+    return torch::optional<torch::ScalarType>{from_ruby<torch::ScalarType>(x)};
+  }
+}
 
 template<>
 inline
-ScalarType from_ruby<ScalarType>(Object x)
+torch::optional<int64_t> from_ruby<torch::optional<int64_t>>(Object x)
 {
-  return ScalarType(x);
+  if (x.is_nil()) {
+    return torch::nullopt;
+  } else {
+    return torch::optional<int64_t>{from_ruby<int64_t>(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
+torch::optional<double> from_ruby<torch::optional<double>>(Object x)
+{
+  if (x.is_nil()) {
+    return torch::nullopt;
+  } else {
+    return torch::optional<double>{from_ruby<double>(x)};
+  }
+}
 
 template<>
 inline
-OptionalScalarType from_ruby<OptionalScalarType>(Object x)
+torch::optional<bool> from_ruby<torch::optional<bool>>(Object x)
 {
-  return OptionalScalarType(x);
+  if (x.is_nil()) {
+    return torch::nullopt;
+  } else {
+    return torch::optional<bool>{from_ruby<bool>(x)};
+  }
 }
 
-typedef torch::Device Device;
+template<>
+inline
+torch::optional<Scalar> from_ruby<torch::optional<Scalar>>(Object x)
+{
+  if (x.is_nil()) {
+    return torch::nullopt;
+  } else {
+    return torch::optional<Scalar>{from_ruby<Scalar>(x)};
+  }
+}
 
+Object wrap(bool x);
+Object wrap(int64_t x);
+Object wrap(double x);
+Object wrap(torch::Tensor x);
+Object wrap(torch::Scalar x);
+Object wrap(torch::ScalarType x);
+Object wrap(torch::QScheme x);
 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);
+Object wrap(std::vector<torch::Tensor> x);