torch-rb 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5224c74f6e74ed04396dfa0414400af5cb20bc5e654320421116723ffcb8e83
-  data.tar.gz: 6a2881ddacb7610a231ebd5a1c24d0f71a2662f16f360102141dfd0893c13346
+  metadata.gz: bd10ea76fc9cde319cad48a1b3bd298384c4f47812d9be5ee9016c44151458a0
+  data.tar.gz: e8391c2bc4ccae67ca0c2e402e431e99a683023285952edbd3f011a18793dfb6
 SHA512:
-  metadata.gz: 045432235e1c691ce85fb937a0562d93b1d9bc312fc648d40dafcc24857eeec4f84e6ceab397793171b0046ccfd785a6caeba37902925dcff1f73c760dd57cec
-  data.tar.gz: 2520fa17dcd13be52aaf1256f431d2951f8113f862189b8691f877dcb48ac9f71ac70719600e27d8c8972494c0b7f11c0983c3330fed7ca6aeed552e8500ec22
+  metadata.gz: c290b76e1d18e88c46ec2bd544471cc5922de4741a0095786ba00415b2fa6ae52023b0c296365a7af6a81143515c36ccd3dbe69d11aea5138fbcd81b6e687bf6
+  data.tar.gz: bc35fd6f9c9ed38b12caf98158f61a6d9827e967c36f8fbcf46f64331cc96c03de3105f4bc0b5b70c911d25ce223ea0085c18537cff677e84bf3d564ce0058ab

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.9.2 (2022-02-03)
+
+- Added support for setting `nil` gradient
+- Added checks when setting gradient
+- Fixed precision with `Torch.tensor` method
+- Fixed memory issue when creating tensor for `ByteStorage`
+
 ## 0.9.1 (2022-02-02)
 
 - Moved `like` methods to C++

data/ext/torch/nn.cpp

@@ -98,8 +98,11 @@ void init_nn(Rice::Module& m) {
         auto grad = self.grad();
         return grad.defined() ? Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Nil;
       })
+    // can't use grad=
+    // assignment methods fail with Ruby 3.0
+    // TODO add checks like Tensor
     .define_method(
-      "grad=",
+      "_set_grad",
       [](Parameter& self, torch::Tensor& grad) {
         self.mutable_grad() = grad;
       })

data/ext/torch/templates.h

@@ -41,6 +41,40 @@ using torch::nn::init::NonlinearityType;
 #define RETURN_NIL                                                   \
   return Qnil;
 
+namespace Rice::detail
+{
+  template<typename T>
+  struct Type<c10::complex<T>>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<typename T>
+  class To_Ruby<c10::complex<T>>
+  {
+  public:
+    VALUE convert(c10::complex<T> const& x)
+    {
+      return rb_dbl_complex_new(x.real(), x.imag());
+    }
+  };
+
+  template<typename T>
+  class From_Ruby<c10::complex<T>>
+  {
+  public:
+    c10::complex<T> convert(VALUE x)
+    {
+      VALUE real = rb_funcall(x, rb_intern("real"), 0);
+      VALUE imag = rb_funcall(x, rb_intern("imag"), 0);
+      return c10::complex<T>(From_Ruby<T>().convert(real), From_Ruby<T>().convert(imag));
+    }
+  };
+}
+
 namespace Rice::detail
 {
   template<>

data/ext/torch/tensor.cpp

@@ -10,28 +10,6 @@
 using namespace Rice;
 using torch::indexing::TensorIndex;
 
-namespace Rice::detail
-{
-  template<typename T>
-  struct Type<c10::complex<T>>
-  {
-    static bool verify()
-    {
-      return true;
-    }
-  };
-
-  template<typename T>
-  class To_Ruby<c10::complex<T>>
-  {
-  public:
-    VALUE convert(c10::complex<T> const& x)
-    {
-      return rb_dbl_complex_new(x.real(), x.imag());
-    }
-  };
-}
-
 template<typename T>
 Array flat_data(Tensor& tensor) {
   Tensor view = tensor.reshape({tensor.numel()});
@@ -189,9 +167,31 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
         auto grad = self.grad();
         return grad.defined() ? Object(Rice::detail::To_Ruby<torch::Tensor>().convert(grad)) : Nil;
       })
+    // can't use grad=
+    // assignment methods fail with Ruby 3.0
     .define_method(
-      "grad=",
-      [](Tensor& self, torch::Tensor& grad) {
+      "_set_grad",
+      [](Tensor& self, Rice::Object value) {
+        if (value.is_nil()) {
+          self.mutable_grad().reset();
+          return;
+        }
+
+        const auto& grad = Rice::detail::From_Ruby<torch::Tensor>().convert(value.value());
+
+        // TODO support sparse grad
+        if (!grad.options().type_equal(self.options())) {
+          rb_raise(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");
+        }
+
+        if (!self.sizes().equals(grad.sizes())) {
+          rb_raise(rb_eArgError, "assigned grad has data of a different size");
+        }
+
         self.mutable_grad() = grad;
       })
     .define_method(
@@ -281,7 +281,7 @@ void init_tensor(Rice::Module& m, Rice::Class& c, Rice::Class& rb_cTensorOptions
       })
     .define_method(
       "_to",
-      [](Tensor& self, torch::Device device, int dtype, bool non_blocking, bool copy) {
+      [](Tensor& self, torch::Device& device, int dtype, bool non_blocking, bool copy) {
         return self.to(device, (torch::ScalarType) dtype, non_blocking, copy);
       });
 

data/ext/torch/torch.cpp

@@ -6,6 +6,23 @@
 #include "templates.h"
 #include "utils.h"
 
+template<typename T>
+torch::Tensor make_tensor(Rice::Array a, std::vector<int64_t> size, const torch::TensorOptions &options) {
+  std::vector<T> vec;
+  for (long i = 0; i < a.size(); i++) {
+    vec.push_back(Rice::detail::From_Ruby<T>().convert(a[i].value()));
+  }
+
+  // hack for requires_grad error
+  auto requires_grad = options.requires_grad();
+  torch::Tensor t = torch::tensor(vec, options.requires_grad(c10::nullopt));
+  if (requires_grad) {
+    t.set_requires_grad(true);
+  }
+
+  return t.reshape(size);
+}
+
 void init_torch(Rice::Module& m) {
   m.add_handler<torch::Error>(handle_error);
   add_torch_functions(m);
@@ -61,35 +78,28 @@ void init_torch(Rice::Module& m) {
       "_tensor",
       [](Rice::Array a, std::vector<int64_t> size, const torch::TensorOptions &options) {
         auto dtype = options.dtype();
-        torch::Tensor t;
-        if (dtype == torch::kBool) {
-          std::vector<uint8_t> vec;
-          for (long i = 0; i < a.size(); i++) {
-            vec.push_back(Rice::detail::From_Ruby<bool>().convert(a[i].value()));
-          }
-          t = torch::tensor(vec, options);
-        } else if (dtype == torch::kComplexFloat || dtype == torch::kComplexDouble) {
-          // TODO use template
-          std::vector<c10::complex<double>> vec;
-          Object obj;
-          for (long i = 0; i < a.size(); i++) {
-            obj = a[i];
-            vec.push_back(c10::complex<double>(Rice::detail::From_Ruby<double>().convert(obj.call("real").value()), Rice::detail::From_Ruby<double>().convert(obj.call("imag").value())));
-          }
-          t = torch::tensor(vec, options);
+        if (dtype == torch::kByte) {
+          return make_tensor<uint8_t>(a, size, options);
+        } else if (dtype == torch::kChar) {
+          return make_tensor<int8_t>(a, size, options);
+        } else if (dtype == torch::kShort) {
+          return make_tensor<int16_t>(a, size, options);
+        } else if (dtype == torch::kInt) {
+          return make_tensor<int32_t>(a, size, options);
+        } else if (dtype == torch::kLong) {
+          return make_tensor<int64_t>(a, size, options);
+        } else if (dtype == torch::kFloat) {
+          return make_tensor<float>(a, size, options);
+        } else if (dtype == torch::kDouble) {
+          return make_tensor<double>(a, size, options);
+        } else if (dtype == torch::kBool) {
+          return make_tensor<uint8_t>(a, size, options);
+        } else if (dtype == torch::kComplexFloat) {
+          return make_tensor<c10::complex<float>>(a, size, options);
+        } else if (dtype == torch::kComplexDouble) {
+          return make_tensor<c10::complex<double>>(a, size, options);
         } else {
-          std::vector<float> vec;
-          for (long i = 0; i < a.size(); i++) {
-            vec.push_back(Rice::detail::From_Ruby<float>().convert(a[i].value()));
-          }
-          // hack for requires_grad error
-          if (options.requires_grad()) {
-            t = torch::tensor(vec, options.requires_grad(c10::nullopt));
-            t.set_requires_grad(true);
-          } else {
-            t = torch::tensor(vec, options);
-          }
+          throw std::runtime_error("Unsupported type");
         }
-        return t.reshape(size);
       });
 }

data/lib/torch/nn/parameter.rb

@@ -1,6 +1,9 @@
 module Torch
   module NN
     class Parameter < Tensor
+      # fix for issue w/ assignment methods
+      alias_method :grad=, :_set_grad
+
       def self.new(data = nil, requires_grad: true)
         data = Tensor.new unless data
         _make_subclass(data, requires_grad)

data/lib/torch/tensor.rb

@@ -8,6 +8,9 @@ module Torch
     alias_method :ndim, :dim
     alias_method :ndimension, :dim
 
+    # fix for issue w/ assignment methods
+    alias_method :grad=, :_set_grad
+
     # use alias_method for performance
     alias_method :+, :add
     alias_method :-, :sub

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
 end

data/lib/torch.rb

@@ -267,7 +267,7 @@ module Torch
         args.first.send(dtype).to(device)
       elsif args.size == 1 && args.first.is_a?(ByteStorage) && dtype == :uint8
         bytes = args.first.bytes
-        Torch._from_blob(bytes, [bytes.bytesize], TensorOptions.new.dtype(DTYPE_TO_ENUM[dtype]))
+        Torch._from_blob_ref(bytes, [bytes.bytesize], TensorOptions.new.dtype(DTYPE_TO_ENUM[dtype]))
       elsif args.size == 1 && args.first.is_a?(Array)
         Torch.tensor(args.first, dtype: dtype, device: device)
       elsif args.size == 0
@@ -320,12 +320,17 @@ module Torch
       raise Error, "Cannot convert #{ndarray.class.name} to tensor" unless dtype
       options = tensor_options(device: "cpu", dtype: dtype[0])
       # TODO pass pointer to array instead of creating string
-      str = ndarray.to_string
-      tensor = _from_blob(str, ndarray.shape, options)
+      _from_blob_ref(ndarray.to_string, ndarray.shape, options)
+    end
+
+    # private
+    # TODO use keepAlive in Rice (currently segfaults)
+    def _from_blob_ref(data, size, options)
+      tensor = _from_blob(data, size, options)
       # from_blob does not own the data, so we need to keep
       # a reference to it for duration of tensor
       # can remove when passing pointer directly
-      tensor.instance_variable_set("@_numo_str", str)
+      tensor.instance_variable_set("@_numo_data", data)
       tensor
     end
 
@@ -406,6 +411,12 @@ module Torch
         end
       end
 
+      # TODO check each dimensions for consistency in future
+      raise Error, "Inconsistent dimensions" if data.size != size.inject(1, :*)
+
+      # TOOD move to C++
+      data = data.map { |v| v ? 1 : 0 } if options[:dtype] == :bool
+
       _tensor(data, size, tensor_options(**options))
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Andrew Kane