torch-rb 0.22.2 → 0.23.1

data/ext/torch/device.cpp

@@ -8,7 +8,8 @@
 #include "utils.h"
 
 void init_device(Rice::Module& m) {
-  Rice::define_class_under<torch::Device>(m, "Device")
+  auto rb_cDevice = Rice::define_class_under<torch::Device>(m, "Device");
+  rb_cDevice
     .define_constructor(Rice::Constructor<torch::Device, const std::string&>())
     .define_method(
       "_index",
@@ -28,8 +29,10 @@ void init_device(Rice::Module& m) {
         return s.str();
       })
     .define_method(
-      "_str",
+      "to_s",
       [](torch::Device& self) {
         return self.str();
       });
+
+  THPDeviceClass = rb_cDevice.value();
 }

data/ext/torch/nn.cpp

@@ -1,3 +1,4 @@
+#include <optional>
 #include <utility>
 
 #include <torch/torch.h>
@@ -95,7 +96,7 @@ void init_nn(Rice::Module& m) {
       "grad",
       [](Parameter& self) {
         auto grad = self.grad();
-        return grad.defined() ? Rice::Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Rice::Nil;
+        return grad.defined() ? std::optional<torch::Tensor>{grad} : std::nullopt;
       })
     // can't use grad=
     // assignment methods fail with Ruby 3.0

data/ext/torch/ruby_arg_parser.cpp

@@ -7,6 +7,7 @@
 
 #include "ruby_arg_parser.h"
 
+VALUE THPDeviceClass = Qnil;
 VALUE THPGeneratorClass = Qnil;
 VALUE THPVariableClass = Qnil;
 
@@ -119,7 +120,7 @@ bool is_tensor_list(VALUE obj, int argnum, bool throw_error) {
     VALUE iobj = rb_ary_entry(obj, idx);
     if (!THPVariable_Check(iobj)) {
       if (throw_error) {
-        rb_raise(rb_eArgError, "expected Tensor as element %d in argument %d, but got %s",
+        throw Rice::Exception(rb_eArgError, "expected Tensor as element %d in argument %d, but got %s",
             static_cast<int>(idx), argnum, rb_obj_classname(obj));
       }
       return false;
@@ -257,7 +258,7 @@ auto FunctionParameter::check(VALUE obj, int argnum) -> bool {
     case ParameterType::LAYOUT: return SYMBOL_P(obj);
     case ParameterType::MEMORY_FORMAT: return false; // return THPMemoryFormat_Check(obj);
     case ParameterType::QSCHEME: return false; // return THPQScheme_Check(obj);
-    case ParameterType::DEVICE: return RB_TYPE_P(obj, T_STRING); // TODO check device
+    case ParameterType::DEVICE: return RB_TYPE_P(obj, T_STRING) || THPDevice_Check(obj);
     case ParameterType::STRING: return RB_TYPE_P(obj, T_STRING);
     case ParameterType::SYM_INT: return is_int_or_symint(obj);
     case ParameterType::SYM_INT_LIST: return is_int_or_symint_list(obj, size);
@@ -582,10 +583,10 @@ static void extra_args(const FunctionSignature& signature, ssize_t nargs) {
   const long min_args = signature.min_args;
   const long nargs_ = nargs;
   if (min_args != max_pos_args) {
-    rb_raise(rb_eArgError, "%s() takes from %ld to %ld positional arguments but %ld were given",
+    throw Rice::Exception(rb_eArgError, "%s() takes from %ld to %ld positional arguments but %ld were given",
         signature.name.c_str(), min_args, max_pos_args, nargs_);
   }
-  rb_raise(rb_eArgError, "%s() takes %ld positional argument%s but %ld %s given",
+  throw Rice::Exception(rb_eArgError, "%s() takes %ld positional argument%s but %ld %s given",
       signature.name.c_str(),
       max_pos_args, max_pos_args == 1 ? "" : "s",
       nargs_, nargs == 1 ? "was" : "were");
@@ -607,7 +608,7 @@ static void missing_args(const FunctionSignature& signature, int idx) {
     }
   }
 
-  rb_raise(rb_eArgError, "%s() missing %d required positional argument%s: %s",
+  throw Rice::Exception(rb_eArgError, "%s() missing %d required positional argument%s: %s",
       signature.name.c_str(),
       num_missing,
       num_missing == 1 ? "s" : "",
@@ -635,23 +636,23 @@ static void extra_kwargs(FunctionSignature& signature, VALUE kwargs, ssize_t num
     key = rb_ary_entry(keys, 0);
 
     if (!THPUtils_checkSymbol(key)) {
-      rb_raise(rb_eArgError, "keywords must be symbols, not %s", rb_obj_classname(key));
+      throw Rice::Exception(rb_eArgError, "keywords must be symbols, not %s", rb_obj_classname(key));
     }
 
     auto param_idx = find_param(signature, key);
     if (param_idx < 0) {
-      rb_raise(rb_eArgError, "%s() got an unexpected keyword argument '%s'",
+      throw Rice::Exception(rb_eArgError, "%s() got an unexpected keyword argument '%s'",
           signature.name.c_str(), rb_id2name(rb_to_id(key)));
     }
 
     if (param_idx < num_pos_args) {
-      rb_raise(rb_eArgError, "%s() got multiple values for argument '%s'",
+      throw Rice::Exception(rb_eArgError, "%s() got multiple values for argument '%s'",
           signature.name.c_str(), rb_id2name(rb_to_id(key)));
     }
   }
 
   // this should never be hit
-  rb_raise(rb_eArgError, "invalid keyword arguments");
+  throw Rice::Exception(rb_eArgError, "invalid keyword arguments");
 }
 
 VALUE missing = Qundef;
@@ -739,12 +740,12 @@ bool FunctionSignature::parse(VALUE self, VALUE args, VALUE kwargs, VALUE dst[],
     } else if (raise_exception) {
       if (is_kwd) {
         // foo(): argument 'other' must be str, not int
-        rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, not %s",
+        throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, not %s",
             name.c_str(), param.name.c_str(), param.type_name().c_str(),
             rb_obj_classname(obj));
       } else {
         // foo(): argument 'other' (position 2) must be str, not int
-        rb_raise(rb_eArgError, "%s(): argument '%s' (position %ld) must be %s, not %s",
+        throw Rice::Exception(rb_eArgError, "%s(): argument '%s' (position %ld) must be %s, not %s",
             name.c_str(), param.name.c_str(), static_cast<long>(arg_pos + 1),
             param.type_name().c_str(), rb_obj_classname(obj));
       }

data/ext/torch/ruby_arg_parser.h

@@ -165,7 +165,7 @@ inline std::array<at::Tensor, N> RubyArgs::tensorlist_n(int i) {
   Check_Type(arg, T_ARRAY);
   auto size = RARRAY_LEN(arg);
   if (size != N) {
-    rb_raise(rb_eArgError, "expected array of %d elements but got %d", N, static_cast<int>(size));
+    throw Rice::Exception(rb_eArgError, "expected array of %d elements but got %d", N, static_cast<int>(size));
   }
   for (int idx = 0; idx < size; idx++) {
     VALUE obj = rb_ary_entry(arg, idx);
@@ -206,7 +206,7 @@ inline std::vector<int64_t> RubyArgs::intlistWithDefault(int i, std::vector<int6
     if (FIXNUM_P(obj)) {
       res[idx] = Rice::detail::From_Ruby<int64_t>().convert(obj);
     } else {
-      rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
+      throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
           signature.name.c_str(), signature.params[i].name.c_str(),
           signature.params[i].type_name().c_str(), rb_obj_classname(obj), idx + 1);
     }
@@ -270,7 +270,7 @@ inline ScalarType RubyArgs::scalartype(int i) {
 
   auto it = dtype_map.find(args[i]);
   if (it == dtype_map.end()) {
-    rb_raise(rb_eArgError, "invalid dtype: %s", rb_id2name(rb_to_id(args[i])));
+    throw Rice::Exception(rb_eArgError, "invalid dtype: %s", rb_id2name(rb_to_id(args[i])));
   }
   return it->second;
 }
@@ -321,7 +321,7 @@ inline c10::OptionalArray<double> RubyArgs::doublelistOptional(int i) {
     if (FIXNUM_P(obj) || RB_FLOAT_TYPE_P(obj)) {
       res[idx] = Rice::detail::From_Ruby<double>().convert(obj);
     } else {
-      rb_raise(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
+      throw Rice::Exception(rb_eArgError, "%s(): argument '%s' must be %s, but found element of type %s at pos %d",
           signature.name.c_str(), signature.params[i].name.c_str(),
           signature.params[i].type_name().c_str(), rb_obj_classname(obj), idx + 1);
     }
@@ -338,7 +338,7 @@ inline at::Layout RubyArgs::layout(int i) {
 
   auto it = layout_map.find(args[i]);
   if (it == layout_map.end()) {
-    rb_raise(rb_eArgError, "invalid layout: %s", rb_id2name(rb_to_id(args[i])));
+    throw Rice::Exception(rb_eArgError, "invalid layout: %s", rb_id2name(rb_to_id(args[i])));
   }
   return it->second;
 }
@@ -357,8 +357,11 @@ inline at::Device RubyArgs::device(int i) {
   if (NIL_P(args[i])) {
     return at::Device("cpu");
   }
-  const std::string &device_str = THPUtils_unpackString(args[i]);
-  return at::Device(device_str);
+  if (RB_TYPE_P(args[i], T_STRING)) {
+    const std::string &device_str = THPUtils_unpackString(args[i]);
+    return at::Device(device_str);
+  }
+  return Rice::detail::From_Ruby<at::Device>().convert(args[i]);
 }
 
 inline at::Device RubyArgs::deviceWithDefault(int i, const at::Device& default_device) {
@@ -466,7 +469,7 @@ struct RubyArgParser {
     template<int N>
     inline RubyArgs parse(VALUE self, int argc, VALUE* argv, ParsedArgs<N> &dst) {
       if (N < max_args) {
-        rb_raise(rb_eArgError, "RubyArgParser: dst ParsedArgs buffer does not have enough capacity, expected %d (got %d)", static_cast<int>(max_args), N);
+        throw Rice::Exception(rb_eArgError, "RubyArgParser: dst ParsedArgs buffer does not have enough capacity, expected %d (got %d)", static_cast<int>(max_args), N);
       }
       return raw_parse(self, argc, argv, dst.args);
     }
@@ -490,7 +493,7 @@ struct RubyArgParser {
       print_error(self, args, kwargs, parsed_args);
 
       // TODO better message
-      rb_raise(rb_eArgError, "No matching signatures");
+      throw Rice::Exception(rb_eArgError, "No matching signatures");
     }
 
     void print_error(VALUE self, VALUE args, VALUE kwargs, VALUE parsed_args[]) {

data/ext/torch/templates.h

@@ -55,7 +55,7 @@ namespace Rice::detail {
     explicit To_Ruby(Arg* arg) : arg_(arg) { }
 
     VALUE convert(c10::complex<T> const& x) {
-      return rb_dbl_complex_new(x.real(), x.imag());
+      return protect(rb_dbl_complex_new, x.real(), x.imag());
     }
 
   private:
@@ -69,11 +69,11 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+    double is_convertible(VALUE value) { return Convertible::Exact; }
 
     c10::complex<T> convert(VALUE x) {
-      VALUE real = rb_funcall(x, rb_intern("real"), 0);
-      VALUE imag = rb_funcall(x, rb_intern("imag"), 0);
+      VALUE real = protect(rb_funcall, x, rb_intern("real"), 0);
+      VALUE imag = protect(rb_funcall, x, rb_intern("imag"), 0);
       return c10::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imag));
     }
 
@@ -93,7 +93,7 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+    double is_convertible(VALUE value) { return Convertible::Exact; }
 
     FanModeType convert(VALUE x) {
       auto s = String(x).str();
@@ -122,7 +122,7 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+    double is_convertible(VALUE value) { return Convertible::Exact; }
 
     NonlinearityType convert(VALUE x) {
       auto s = String(x).str();
@@ -169,7 +169,7 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+    double is_convertible(VALUE value) { return Convertible::Exact; }
 
     Scalar convert(VALUE x) {
       if (FIXNUM_P(x)) {

data/ext/torch/tensor.cpp

@@ -1,3 +1,4 @@
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -28,15 +29,15 @@ Array flat_data(Tensor& tensor) {
 Rice::Class rb_cTensor;
 
 std::vector<TensorIndex> index_vector(Array a) {
-  Object obj;
-
   std::vector<TensorIndex> indices;
   indices.reserve(a.size());
 
   for (long i = 0; i < a.size(); i++) {
-    obj = a[i];
+    Object obj(a[i]);
 
-    if (obj.is_instance_of(rb_cInteger)) {
+    if (obj.is_nil()) {
+      indices.push_back(torch::indexing::None);
+    } else if (obj.is_instance_of(rb_cInteger)) {
       indices.push_back(Rice::detail::From_Ruby<int64_t>().convert(obj.value()));
     } else if (obj.is_instance_of(rb_cRange)) {
       torch::optional<c10::SymInt> start_index = torch::nullopt;
@@ -64,12 +65,10 @@ std::vector<TensorIndex> index_vector(Array a) {
       indices.push_back(torch::indexing::Slice(start_index, stop_index));
     } else if (obj.is_instance_of(rb_cTensor)) {
       indices.push_back(Rice::detail::From_Ruby<Tensor>().convert(obj.value()));
-    } else if (obj.is_nil()) {
-      indices.push_back(torch::indexing::None);
-    } else if (obj == Rice::True || obj == Rice::False) {
+    } else if (obj.value() == Qtrue || obj.value() == Qfalse) {
       indices.push_back(Rice::detail::From_Ruby<bool>().convert(obj.value()));
     } else {
-      throw Rice::Exception(rb_eArgError, "Unsupported index type: %s", rb_obj_classname(obj));
+      throw Rice::Exception(rb_eArgError, "Unsupported index type: %s", rb_obj_classname(obj.value()));
     }
   }
   return indices;
@@ -102,7 +101,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
   add_tensor_functions(rb_cTensor);
   THPVariableClass = rb_cTensor.value();
 
-  rb_define_method(rb_cTensor, "backward", (VALUE (*)(...)) tensor__backward, -1);
+  rb_define_method(rb_cTensor, "backward", tensor__backward, -1);
 
   rb_cTensor
     .define_method("cuda?", [](Tensor& self) { return self.is_cuda(); })
@@ -168,7 +167,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
       "grad",
       [](Tensor& self) {
         auto grad = self.grad();
-        return grad.defined() ? Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Rice::Nil;
+        return grad.defined() ? std::optional<torch::Tensor>{grad} : std::nullopt;
       })
     // can't use grad=
     // assignment methods fail with Ruby 3.0
@@ -184,15 +183,15 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
 
         // TODO support sparse grad
         if (!grad.options().type_equal(self.options())) {
-          rb_raise(rb_eArgError, "assigned grad has data of a different type");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data of a different type");
         }
 
         if (self.is_cuda() && grad.get_device() != self.get_device()) {
-          rb_raise(rb_eArgError, "assigned grad has data located on a different device");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data located on a different device");
         }
 
         if (!self.sizes().equals(grad.sizes())) {
-          rb_raise(rb_eArgError, "assigned grad has data of a different size");
+          throw Rice::Exception(rb_eArgError, "assigned grad has data of a different size");
         }
 
         self.mutable_grad() = grad;
@@ -215,7 +214,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
         return s.str();
       })
     .define_method(
-      "_device",
+      "device",
       [](Tensor& self) {
         return self.device();
       })

data/ext/torch/utils.h

@@ -8,7 +8,7 @@
 #include <rice/stl.hpp>
 
 static_assert(
-  TORCH_VERSION_MAJOR == 2 && TORCH_VERSION_MINOR == 9,
+  TORCH_VERSION_MAJOR == 2 && TORCH_VERSION_MINOR == 10,
   "Incompatible LibTorch version"
 );
 
@@ -20,6 +20,7 @@ inline void handle_global_error(const torch::Error& ex) {
 
 // keep THP prefix for now to make it easier to compare code
 
+extern VALUE THPDeviceClass;
 extern VALUE THPGeneratorClass;
 extern VALUE THPVariableClass;
 
@@ -48,6 +49,10 @@ inline bool THPUtils_checkScalar(VALUE obj) {
   return FIXNUM_P(obj) || RB_FLOAT_TYPE_P(obj) || RB_TYPE_P(obj, T_COMPLEX);
 }
 
+inline bool THPDevice_Check(VALUE obj) {
+  return rb_obj_is_kind_of(obj, THPDeviceClass);
+}
+
 inline bool THPGenerator_Check(VALUE obj) {
   return rb_obj_is_kind_of(obj, THPGeneratorClass);
 }

data/lib/torch/device.rb

@@ -8,7 +8,6 @@ module Torch
       extra = ", index: #{index.inspect}" if index?
       "device(type: #{type.inspect}#{extra})"
     end
-    alias_method :to_s, :inspect
 
     def ==(other)
       eql?(other)

data/lib/torch/tensor.rb

@@ -115,7 +115,7 @@ module Torch
       if numel != 1
         raise Error, "only one element tensors can be converted to Ruby scalars"
       end
-      to_a.first
+      to_a.flatten.first
     end
 
     def to_i
@@ -210,10 +210,5 @@ module Torch
         raise TypeError, "#{self.class} can't be coerced into #{other.class}"
       end
     end
-
-    # TODO return Device instead of String in 0.19.0
-    def device
-      _device._str
-    end
   end
 end

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.22.2"
+  VERSION = "0.23.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.22.2
+  version: 0.23.1
 platform: ruby
 authors:
 - Andrew Kane
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '4.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '4.8'
 email: andrew@ankane.org
 executables: []
 extensions:
@@ -241,7 +241,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Deep learning for Ruby, powered by LibTorch
 test_files: []