torch-rb 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ef4b5215eabaac0dfa2c95fa19ec47c84ffdc2caaa004b3eed5fd0d88329d4c
-  data.tar.gz: 3c41ea854a8dc791b6b67631a1e9502f47c26c1afb4eff0e77da3885b5b57e8e
+  metadata.gz: 859f5858ce45f6a73fbf9afd6073e3af798ac7ea64713405c54df0fc40b0a1e6
+  data.tar.gz: 4c371640902d1226c69135874aaa076251d2539c56dc78479203bc28473b071b
 SHA512:
-  metadata.gz: 2378a07b1b7b5470909f920f9f2ace055b2d8f860e1e530ddcfe57b02aa79b61ddd65c9441d62107065d8326f81af90f6741f67eab1f078de85a5a0c140a1f27
-  data.tar.gz: db2d6c16a388571377d920a5ffa464447501441730feb8b016a7090f7a81e2d0ce0a4626b99081f2b9d07fe9448dc1247adb9e8d1906d4a87c4d6e1023d39be5
+  metadata.gz: f8ab6c1af0da9ad36f1fa7fae0cb67b54a60c11783d13cedc4c66164fb1fcb40638a68bbd78fa0f644e6d6d1c7df44d83c68c61bc0e41ea4c361817b0fe7b9cd
+  data.tar.gz: f64913cf8c2566539fef54e29e42173f4e2e0529ea49d381c6cf41af64868653865fc2cfa366f5086e035b45008a07f2d620a000c64dabf92e3c9134489b5a6b

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.7.0 (2021-05-23)
+
+- Updated to Rice 4
+- Added support for complex numbers
+
 ## 0.6.0 (2021-03-25)
 
 - Updated LibTorch to 1.8.0

data/codegen/generate_functions.rb

@@ -75,7 +75,7 @@ def write_body(type, method_defs, attach_defs)
     // do not edit by hand
 
     #include <torch/torch.h>
-    #include <rice/Module.hpp>
+    #include <rice/rice.hpp>
 
     #include "ruby_arg_parser.h"
     #include "templates.h"
@@ -119,7 +119,7 @@ def generate_attach_def(name, type, def_method)
 end
 
 def generate_method_def(name, functions, type, def_method)
-  assign_self = type == "tensor" ? "\n  Tensor& self = from_ruby<Tensor&>(self_);" : ""
+  assign_self = type == "tensor" ? "\n  Tensor& self = Rice::detail::From_Ruby<Tensor&>().convert(self_);" : ""
 
   functions = group_overloads(functions, type)
   signatures = functions.map { |f| f["signature"] }

data/ext/torch/cuda.cpp

@@ -1,14 +1,14 @@
 #include <torch/torch.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_cuda(Rice::Module& m) {
   Rice::define_module_under(m, "CUDA")
     .add_handler<torch::Error>(handle_error)
-    .define_singleton_method("available?", &torch::cuda::is_available)
-    .define_singleton_method("device_count", &torch::cuda::device_count)
-    .define_singleton_method("manual_seed", &torch::cuda::manual_seed)
-    .define_singleton_method("manual_seed_all", &torch::cuda::manual_seed_all);
+    .define_singleton_function("available?", &torch::cuda::is_available)
+    .define_singleton_function("device_count", &torch::cuda::device_count)
+    .define_singleton_function("manual_seed", &torch::cuda::manual_seed)
+    .define_singleton_function("manual_seed_all", &torch::cuda::manual_seed_all);
 }

data/ext/torch/device.cpp

@@ -1,19 +1,26 @@
 #include <torch/torch.h>
 
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_device(Rice::Module& m) {
   Rice::define_class_under<torch::Device>(m, "Device")
     .add_handler<torch::Error>(handle_error)
-    .define_constructor(Rice::Constructor<torch::Device, std::string>())
-    .define_method("index", &torch::Device::index)
-    .define_method("index?", &torch::Device::has_index)
+    .define_constructor(Rice::Constructor<torch::Device, const std::string&>())
+    .define_method(
+      "index",
+      [](torch::Device& self) {
+        return self.index();
+      })
+    .define_method(
+      "index?",
+      [](torch::Device& self) {
+        return self.has_index();
+      })
     .define_method(
       "type",
-      *[](torch::Device& self) {
+      [](torch::Device& self) {
         std::stringstream s;
         s << self.type();
         return s.str();

data/ext/torch/ext.cpp

@@ -1,12 +1,14 @@
-#include <rice/Module.hpp>
+#include <torch/torch.h>
+
+#include <rice/rice.hpp>
 
 void init_nn(Rice::Module& m);
-void init_tensor(Rice::Module& m);
+void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions);
 void init_torch(Rice::Module& m);
 
 void init_cuda(Rice::Module& m);
 void init_device(Rice::Module& m);
-void init_ivalue(Rice::Module& m);
+void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue);
 void init_random(Rice::Module& m);
 
 extern "C"
@@ -14,13 +16,20 @@ void Init_ext()
 {
   auto m = Rice::define_module("Torch");
 
+  // need to define certain classes up front to keep Rice happy
+  auto rb_cIValue = Rice::define_class_under<torch::IValue>(m, "IValue")
+    .define_constructor(Rice::Constructor<torch::IValue>());
+  auto rb_cTensor = Rice::define_class_under<torch::Tensor>(m, "Tensor");
+  auto rb_cTensorOptions = Rice::define_class_under<torch::TensorOptions>(m, "TensorOptions")
+    .define_constructor(Rice::Constructor<torch::TensorOptions>());
+
   // keep this order
   init_torch(m);
-  init_tensor(m);
+  init_tensor(m, rb_cTensor, rb_cTensorOptions);
   init_nn(m);
 
   init_cuda(m);
   init_device(m);
-  init_ivalue(m);
+  init_ivalue(m, rb_cIValue);
   init_random(m);
 }

data/ext/torch/extconf.rb

@@ -1,8 +1,6 @@
 require "mkmf-rice"
 
-abort "Missing stdc++" unless have_library("stdc++")
-
-$CXXFLAGS += " -std=c++14"
+$CXXFLAGS += " -std=c++17 $(optflags)"
 
 # change to 0 for Linux pre-cxx11 ABI version
 $CXXFLAGS += " -D_GLIBCXX_USE_CXX11_ABI=1"

data/ext/torch/ivalue.cpp

@@ -1,18 +1,13 @@
 #include <torch/torch.h>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Hash.hpp>
-#include <rice/Module.hpp>
-#include <rice/String.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
-void init_ivalue(Rice::Module& m) {
+void init_ivalue(Rice::Module& m, Rice::Class& rb_cIValue) {
   // https://pytorch.org/cppdocs/api/structc10_1_1_i_value.html
-  Rice::define_class_under<torch::IValue>(m, "IValue")
+  rb_cIValue
     .add_handler<torch::Error>(handle_error)
-    .define_constructor(Rice::Constructor<torch::IValue>())
     .define_method("bool?", &torch::IValue::isBool)
     .define_method("bool_list?", &torch::IValue::isBoolList)
     .define_method("capsule?", &torch::IValue::isCapsule)
@@ -39,95 +34,98 @@ void init_ivalue(Rice::Module& m) {
     .define_method("tuple?", &torch::IValue::isTuple)
     .define_method(
       "to_bool",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toBool();
       })
     .define_method(
       "to_double",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toDouble();
       })
     .define_method(
       "to_int",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toInt();
       })
     .define_method(
       "to_list",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         auto list = self.toListRef();
         Rice::Array obj;
         for (auto& elem : list) {
-          obj.push(to_ruby<torch::IValue>(torch::IValue{elem}));
+          auto v = torch::IValue{elem};
+          obj.push(Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(v)));
         }
         return obj;
       })
     .define_method(
       "to_string_ref",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toStringRef();
       })
     .define_method(
       "to_tensor",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         return self.toTensor();
       })
     .define_method(
       "to_generic_dict",
-      *[](torch::IValue& self) {
+      [](torch::IValue& self) {
         auto dict = self.toGenericDict();
         Rice::Hash obj;
         for (auto& pair : dict) {
-          obj[to_ruby<torch::IValue>(torch::IValue{pair.key()})] = to_ruby<torch::IValue>(torch::IValue{pair.value()});
+          auto k = torch::IValue{pair.key()};
+          auto v = torch::IValue{pair.value()};
+          obj[Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(k))] = Rice::Object(Rice::detail::To_Ruby<torch::IValue>().convert(v));
         }
         return obj;
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_tensor",
-      *[](torch::Tensor& v) {
+      [](torch::Tensor& v) {
         return torch::IValue(v);
       })
     // TODO create specialized list types?
-    .define_singleton_method(
+    .define_singleton_function(
       "from_list",
-      *[](Rice::Array obj) {
+      [](Rice::Array obj) {
         c10::impl::GenericList list(c10::AnyType::get());
         for (auto entry : obj) {
-          list.push_back(from_ruby<torch::IValue>(entry));
+          list.push_back(Rice::detail::From_Ruby<torch::IValue>().convert(entry.value()));
         }
         return torch::IValue(list);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_string",
-      *[](Rice::String v) {
+      [](Rice::String v) {
         return torch::IValue(v.str());
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_int",
-      *[](int64_t v) {
+      [](int64_t v) {
         return torch::IValue(v);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_double",
-      *[](double v) {
+      [](double v) {
         return torch::IValue(v);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "from_bool",
-      *[](bool v) {
+      [](bool v) {
         return torch::IValue(v);
       })
     // see https://github.com/pytorch/pytorch/blob/master/torch/csrc/jit/python/pybind_utils.h
     // createGenericDict and toIValue
-    .define_singleton_method(
+    .define_singleton_function(
       "from_dict",
-      *[](Rice::Hash obj) {
+      [](Rice::Hash obj) {
         auto key_type = c10::AnyType::get();
         auto value_type = c10::AnyType::get();
         c10::impl::GenericDict elems(key_type, value_type);
         elems.reserve(obj.size());
         for (auto entry : obj) {
-          elems.insert(from_ruby<torch::IValue>(entry.first), from_ruby<torch::IValue>((Rice::Object) entry.second));
+          elems.insert(Rice::detail::From_Ruby<torch::IValue>().convert(entry.first), Rice::detail::From_Ruby<torch::IValue>().convert((Rice::Object) entry.second));
         }
         return torch::IValue(std::move(elems));
       });

data/ext/torch/nn.cpp

@@ -1,6 +1,6 @@
 #include <torch/torch.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "nn_functions.h"
 #include "templates.h"
@@ -19,74 +19,74 @@ void init_nn(Rice::Module& m) {
 
   Rice::define_module_under(rb_mNN, "Init")
     .add_handler<torch::Error>(handle_error)
-    .define_singleton_method(
+    .define_singleton_function(
       "_calculate_gain",
-      *[](NonlinearityType nonlinearity, double param) {
+      [](NonlinearityType nonlinearity, double param) {
         return torch::nn::init::calculate_gain(nonlinearity, param);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_uniform!",
-      *[](Tensor tensor, double low, double high) {
+      [](Tensor tensor, double low, double high) {
         return torch::nn::init::uniform_(tensor, low, high);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_normal!",
-      *[](Tensor tensor, double mean, double std) {
+      [](Tensor tensor, double mean, double std) {
         return torch::nn::init::normal_(tensor, mean, std);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_constant!",
-      *[](Tensor tensor, Scalar value) {
+      [](Tensor tensor, Scalar value) {
         return torch::nn::init::constant_(tensor, value);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_ones!",
-      *[](Tensor tensor) {
+      [](Tensor tensor) {
         return torch::nn::init::ones_(tensor);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_zeros!",
-      *[](Tensor tensor) {
+      [](Tensor tensor) {
         return torch::nn::init::zeros_(tensor);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_eye!",
-      *[](Tensor tensor) {
+      [](Tensor tensor) {
         return torch::nn::init::eye_(tensor);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_dirac!",
-      *[](Tensor tensor) {
+      [](Tensor tensor) {
         return torch::nn::init::dirac_(tensor);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_xavier_uniform!",
-      *[](Tensor tensor, double gain) {
+      [](Tensor tensor, double gain) {
         return torch::nn::init::xavier_uniform_(tensor, gain);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_xavier_normal!",
-      *[](Tensor tensor, double gain) {
+      [](Tensor tensor, double gain) {
         return torch::nn::init::xavier_normal_(tensor, gain);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_kaiming_uniform!",
-      *[](Tensor tensor, double a, FanModeType mode, NonlinearityType nonlinearity) {
+      [](Tensor tensor, double a, FanModeType mode, NonlinearityType nonlinearity) {
         return torch::nn::init::kaiming_uniform_(tensor, a, mode, nonlinearity);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_kaiming_normal!",
-      *[](Tensor tensor, double a, FanModeType mode, NonlinearityType nonlinearity) {
+      [](Tensor tensor, double a, FanModeType mode, NonlinearityType nonlinearity) {
         return torch::nn::init::kaiming_normal_(tensor, a, mode, nonlinearity);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_orthogonal!",
-      *[](Tensor tensor, double gain) {
+      [](Tensor tensor, double gain) {
         return torch::nn::init::orthogonal_(tensor, gain);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_sparse!",
-      *[](Tensor tensor, double sparsity, double std) {
+      [](Tensor tensor, double sparsity, double std) {
         return torch::nn::init::sparse_(tensor, sparsity, std);
       });
 
@@ -94,18 +94,18 @@ void init_nn(Rice::Module& m) {
     .add_handler<torch::Error>(handle_error)
     .define_method(
       "grad",
-      *[](Parameter& self) {
+      [](Parameter& self) {
         auto grad = self.grad();
-        return grad.defined() ? to_ruby<torch::Tensor>(grad) : Nil;
+        return grad.defined() ? Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Nil;
       })
     .define_method(
       "grad=",
-      *[](Parameter& self, torch::Tensor& grad) {
+      [](Parameter& self, torch::Tensor& grad) {
         self.mutable_grad() = grad;
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_make_subclass",
-      *[](Tensor& rd, bool requires_grad) {
+      [](Tensor& rd, bool requires_grad) {
         auto data = rd.detach();
         data.unsafeGetTensorImpl()->set_allow_tensor_metadata_change(true);
         auto var = data.set_requires_grad(requires_grad);

data/ext/torch/random.cpp

@@ -1,20 +1,20 @@
 #include <torch/torch.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_random(Rice::Module& m) {
   Rice::define_module_under(m, "Random")
     .add_handler<torch::Error>(handle_error)
-    .define_singleton_method(
+    .define_singleton_function(
       "initial_seed",
-      *[]() {
+      []() {
         return at::detail::getDefaultCPUGenerator().current_seed();
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "seed",
-      *[]() {
+      []() {
         // TODO set for CUDA when available
         auto generator = at::detail::getDefaultCPUGenerator();
         return generator.seed();