torch-rb 0.9.0 → 0.10.0

data/ext/torch/backends.cpp

@@ -7,11 +7,11 @@
 void init_backends(Rice::Module& m) {
   auto rb_mBackends = Rice::define_module_under(m, "Backends");
 
-   Rice::define_module_under(rb_mBackends, "OpenMP")
+  Rice::define_module_under(rb_mBackends, "OpenMP")
     .add_handler<torch::Error>(handle_error)
     .define_singleton_function("available?", &torch::hasOpenMP);
 
-   Rice::define_module_under(rb_mBackends, "MKL")
+  Rice::define_module_under(rb_mBackends, "MKL")
     .add_handler<torch::Error>(handle_error)
     .define_singleton_function("available?", &torch::hasMKL);
 }

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.cpp

@@ -472,12 +472,12 @@ static void extra_kwargs(FunctionSignature& signature, VALUE kwargs, ssize_t num
     auto param_idx = find_param(signature, key);
     if (param_idx < 0) {
       rb_raise(rb_eArgError, "%s() got an unexpected keyword argument '%s'",
-          signature.name.c_str(), THPUtils_unpackSymbol(key).c_str());
+          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'",
-          signature.name.c_str(), THPUtils_unpackSymbol(key).c_str());
+          signature.name.c_str(), rb_id2name(rb_to_id(key)));
     }
   }
 

data/ext/torch/ruby_arg_parser.h

@@ -235,7 +235,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", THPUtils_unpackSymbol(args[i]).c_str());
+    rb_raise(rb_eArgError, "invalid dtype: %s", rb_id2name(rb_to_id(args[i])));
   }
   return it->second;
 }
@@ -293,7 +293,7 @@ inline c10::optional<at::Layout> RubyArgs::layoutOptional(int i) {
 
   auto it = layout_map.find(args[i]);
   if (it == layout_map.end()) {
-    rb_raise(rb_eArgError, "invalid layout: %s", THPUtils_unpackSymbol(args[i]).c_str());
+    rb_raise(rb_eArgError, "invalid layout: %s", rb_id2name(rb_to_id(args[i])));
   }
   return it->second;
 }
@@ -325,15 +325,15 @@ inline c10::optional<std::string> RubyArgs::stringOptional(int i) {
   return Rice::detail::From_Ruby<std::string>().convert(args[i]);
 }
 
+// string_view does not own data
 inline c10::string_view RubyArgs::stringView(int i) {
-  auto str = Rice::detail::From_Ruby<std::string>().convert(args[i]);
-  return c10::string_view(str.data(), str.size());
+  return c10::string_view(RSTRING_PTR(args[i]), RSTRING_LEN(args[i]));
 }
 
+// string_view does not own data
 inline c10::optional<c10::string_view> RubyArgs::stringViewOptional(int i) {
   if (NIL_P(args[i])) return c10::nullopt;
-  auto str = Rice::detail::From_Ruby<std::string>().convert(args[i]);
-  return c10::string_view(str.data(), str.size());
+  return c10::string_view(RSTRING_PTR(args[i]), RSTRING_LEN(args[i]));
 }
 
 inline int64_t RubyArgs::toInt64(int i) {

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

@@ -16,12 +16,6 @@ inline VALUE THPUtils_internSymbol(const std::string& str) {
   return Rice::Symbol(str);
 }
 
-inline std::string THPUtils_unpackSymbol(VALUE obj) {
-  Check_Type(obj, T_SYMBOL);
-  obj = rb_funcall(obj, rb_intern("to_s"), 0);
-  return std::string(RSTRING_PTR(obj), RSTRING_LEN(obj));
-}
-
 inline std::string THPUtils_unpackString(VALUE obj) {
   Check_Type(obj, T_STRING);
   return std::string(RSTRING_PTR(obj), RSTRING_LEN(obj));

data/lib/torch/inspector.rb

@@ -247,7 +247,7 @@ module Torch
       # length includes spaces and comma between elements
       element_length = formatter.width + 2
       elements_per_line = [1, ((PRINT_OPTS[:linewidth] - indent) / element_length.to_f).floor.to_i].max
-      char_per_line = element_length * elements_per_line
+      _char_per_line = element_length * elements_per_line
 
       if summarize && slf.size(0) > 2 * PRINT_OPTS[:edgeitems]
         data = (

data/lib/torch/nn/functional.rb

@@ -571,7 +571,7 @@ module Torch
         end
 
         def _interp_output_size(closed_over_args)
-          input, size, scale_factor, recompute_scale_factor = closed_over_args
+          input, size, scale_factor, _recompute_scale_factor = closed_over_args
           dim = input.dim - 2
           if size.nil? && scale_factor.nil?
             raise ArgumentError, "either size or scale_factor should be defined"

data/lib/torch/nn/functional_attention.rb

@@ -56,7 +56,7 @@ module Torch
           attn_mask: nil, dropout_p: 0.0
         )
 
-          b, nt, e = q.shape
+          _b, _nt, e = q.shape
 
           q = q / Math.sqrt(e)
 

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
@@ -106,6 +109,7 @@ module Torch
       size(0)
     end
 
+    remove_method :item
     def item
       if numel != 1
         raise Error, "only one element tensors can be converted to Ruby scalars"
@@ -133,18 +137,10 @@ module Torch
       cls.from_string(_data_str).reshape(*shape)
     end
 
-    def new_ones(*size, **options)
-      Torch.ones_like(Torch.empty(*size), **options)
-    end
-
     def requires_grad=(requires_grad)
       _requires_grad!(requires_grad)
     end
 
-    def requires_grad!(requires_grad = true)
-      _requires_grad!(requires_grad)
-    end
-
     def type(dtype)
       if dtype.is_a?(Class)
         raise Error, "Invalid type: #{dtype}" unless TENSOR_TYPE_CLASSES.include?(dtype)

data/lib/torch/utils/data/data_loader.rb

@@ -29,7 +29,7 @@ module Torch
 
           # try to keep the random number generator in sync with Python
           # this makes it easy to compare results
-          base_seed = Torch.empty([], dtype: :int64).random!.item
+          _base_seed = Torch.empty([], dtype: :int64).random!.item
 
           indexes =
             if @shuffle

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 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
 
@@ -377,8 +383,6 @@ module Torch
       to_ruby(_load(File.binread(f)))
     end
 
-    # --- begin tensor creation: https://pytorch.org/cppdocs/notes/tensor_creation.html ---
-
     def tensor(data, **options)
       if options[:dtype].nil? && defined?(Numo::NArray) && data.is_a?(Numo::NArray)
         numo_to_dtype = _dtype_to_numo.map(&:reverse).to_h
@@ -408,42 +412,13 @@ module Torch
         end
       end
 
-      _tensor(data, size, tensor_options(**options))
-    end
-
-    # --- begin like ---
-
-    def ones_like(input, **options)
-      ones(input.size, **like_options(input, options))
-    end
-
-    def empty_like(input, **options)
-      empty(input.size, **like_options(input, options))
-    end
+      # TODO check each dimensions for consistency in future
+      raise Error, "Inconsistent dimensions" if data.size != size.inject(1, :*)
 
-    def full_like(input, fill_value, **options)
-      full(input.size, fill_value, **like_options(input, options))
-    end
+      # TOOD move to C++
+      data = data.map { |v| v ? 1 : 0 } if options[:dtype] == :bool
 
-    def rand_like(input, **options)
-      rand(input.size, **like_options(input, options))
-    end
-
-    def randint_like(input, low, high = nil, **options)
-      # ruby doesn't support input, low = 0, high, ...
-      if high.nil?
-        high = low
-        low = 0
-      end
-      randint(low, high, input.size, **like_options(input, options))
-    end
-
-    def randn_like(input, **options)
-      randn(input.size, **like_options(input, options))
-    end
-
-    def zeros_like(input, **options)
-      zeros(input.size, **like_options(input, options))
+      _tensor(data, size, tensor_options(**options))
     end
 
     # center option
@@ -572,13 +547,5 @@ module Torch
       end
       options
     end
-
-    def like_options(input, options)
-      options = options.dup
-      options[:dtype] ||= input.dtype
-      options[:layout] ||= input.layout
-      options[:device] ||= input.device
-      options
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-23 00:00:00.000000000 Z
+date: 2022-03-13 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.2.22
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Deep learning for Ruby, powered by LibTorch