torch-rb 0.9.1 → 0.10.1

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/ruby_arg_parser.h

@@ -88,18 +88,18 @@ struct RubyArgs {
   inline c10::optional<at::Generator> generator(int i);
   inline at::Storage storage(int i);
   inline at::ScalarType scalartype(int i);
-  // inline at::ScalarType scalartypeWithDefault(int i, at::ScalarType default_scalartype);
+  inline at::ScalarType scalartypeWithDefault(int i, at::ScalarType default_scalartype);
   inline c10::optional<at::ScalarType> scalartypeOptional(int i);
   inline c10::optional<at::Scalar> scalarOptional(int i);
   inline c10::optional<int64_t> toInt64Optional(int i);
   inline c10::optional<bool> toBoolOptional(int i);
   inline c10::optional<double> toDoubleOptional(int i);
   inline c10::OptionalArray<double> doublelistOptional(int i);
-  // inline at::Layout layout(int i);
-  // inline at::Layout layoutWithDefault(int i, at::Layout default_layout);
+  inline at::Layout layout(int i);
+  inline at::Layout layoutWithDefault(int i, at::Layout default_layout);
   inline c10::optional<at::Layout> layoutOptional(int i);
   inline at::Device device(int i);
-  // inline at::Device deviceWithDefault(int i, const at::Device& default_device);
+  inline at::Device deviceWithDefault(int i, const at::Device& default_device);
   // inline c10::optional<at::Device> deviceOptional(int i);
   // inline at::Dimname dimname(int i);
   // inline std::vector<at::Dimname> dimnamelist(int i);
@@ -240,6 +240,11 @@ inline ScalarType RubyArgs::scalartype(int i) {
   return it->second;
 }
 
+inline at::ScalarType RubyArgs::scalartypeWithDefault(int i, at::ScalarType default_scalartype) {
+  if (NIL_P(args[i])) return default_scalartype;
+  return scalartype(i);
+}
+
 inline c10::optional<ScalarType> RubyArgs::scalartypeOptional(int i) {
   if (NIL_P(args[i])) return c10::nullopt;
   return scalartype(i);
@@ -284,8 +289,8 @@ inline c10::OptionalArray<double> RubyArgs::doublelistOptional(int i) {
   return res;
 }
 
-inline c10::optional<at::Layout> RubyArgs::layoutOptional(int i) {
-  if (NIL_P(args[i])) return c10::nullopt;
+inline at::Layout RubyArgs::layout(int i) {
+  if (NIL_P(args[i])) return signature.params[i].default_layout;
 
   static std::unordered_map<VALUE, Layout> layout_map = {
     {ID2SYM(rb_intern("strided")), Layout::Strided},
@@ -298,6 +303,16 @@ inline c10::optional<at::Layout> RubyArgs::layoutOptional(int i) {
   return it->second;
 }
 
+inline at::Layout RubyArgs::layoutWithDefault(int i, at::Layout default_layout) {
+  if (NIL_P(args[i])) return default_layout;
+  return layout(i);
+}
+
+inline c10::optional<at::Layout> RubyArgs::layoutOptional(int i) {
+  if (NIL_P(args[i])) return c10::nullopt;
+  return layout(i);
+}
+
 inline at::Device RubyArgs::device(int i) {
   if (NIL_P(args[i])) {
     return at::Device("cpu");
@@ -306,6 +321,11 @@ inline at::Device RubyArgs::device(int i) {
   return at::Device(device_str);
 }
 
+inline at::Device RubyArgs::deviceWithDefault(int i, const at::Device& default_device) {
+  if (NIL_P(args[i])) return default_device;
+  return device(i);
+}
+
 inline at::MemoryFormat RubyArgs::memoryformat(int i) {
   if (NIL_P(args[i])) return at::MemoryFormat::Contiguous;
   throw std::runtime_error("memoryformat not supported yet");

data/ext/torch/sparse_functions.h

@@ -0,0 +1,6 @@
+// generated by rake generate:functions
+// do not edit by hand
+
+#pragma once
+
+void add_sparse_functions(Rice::Module& m);

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/ext/torch/utils.h

@@ -1,8 +1,15 @@
 #pragma once
 
+#include <torch/torch.h>
+
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
 
+static_assert(
+  TORCH_VERSION_MAJOR == 1 && TORCH_VERSION_MINOR == 11,
+  "Incompatible LibTorch version"
+);
+
 // TODO find better place
 inline void handle_error(torch::Error const & ex) {
   throw Rice::Exception(rb_eRuntimeError, ex.what_without_backtrace());

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/nn/parameter_list.rb

@@ -0,0 +1,48 @@
+module Torch
+  module NN
+    class ParameterList < Module
+      include Enumerable
+
+      def initialize(parameters)
+        super()
+        @initialized = true
+        unless parameters.nil?
+          concat(parameters)
+        end
+      end
+
+      def length
+        @parameters.length
+      end
+      alias_method :count, :length
+      alias_method :size, :length
+
+      def concat(parameters)
+        unless parameters.is_a?(Enumerable)
+          raise TypeError, "ParameterList#concat should be called with an enumerable, but got #{parameters.class.name}"
+        end
+        offset = length
+        parameters.each_with_index do |param, i|
+          register_parameter((offset + i).to_s, param)
+        end
+        self
+      end
+
+      def each(&block)
+        if block_given?
+          @parameters.values.each(&block)
+        else
+          to_enum(:each)
+        end
+      end
+
+      def [](idx)
+        if idx.is_a?(Range)
+          self.class.new(@parameters.values[idx])
+        else
+          @parameters[idx.to_s]
+        end
+      end
+    end
+  end
+end

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.10.1"
 end

data/lib/torch.rb

@@ -40,6 +40,7 @@ require "torch/nn/utils"
 # nn containers
 require "torch/nn/module"
 require "torch/nn/module_list"
+require "torch/nn/parameter_list"
 require "torch/nn/sequential"
 
 # nn convolution layers
@@ -267,7 +268,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 +321,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 +412,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-03 00:00:00.000000000 Z
+date: 2022-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -52,6 +52,7 @@ files:
 - ext/torch/random.cpp
 - ext/torch/ruby_arg_parser.cpp
 - ext/torch/ruby_arg_parser.h
+- ext/torch/sparse_functions.h
 - ext/torch/special.cpp
 - ext/torch/special_functions.h
 - ext/torch/templates.h
@@ -149,6 +150,7 @@ files:
 - lib/torch/nn/nll_loss.rb
 - lib/torch/nn/pairwise_distance.rb
 - lib/torch/nn/parameter.rb
+- lib/torch/nn/parameter_list.rb
 - lib/torch/nn/poisson_nll_loss.rb
 - lib/torch/nn/prelu.rb
 - lib/torch/nn/reflection_pad1d.rb
@@ -227,7 +229,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Deep learning for Ruby, powered by LibTorch