torch-rb 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7b85027dfbb5a3d8de3741d00f4256fd13a6b5496a123564472a48d8a084c1b
-  data.tar.gz: 5c684e45ec115ce3b9cc5a3e223ee73cac3dce5fbacae1bd4d4faa7cf49adc5f
+  metadata.gz: 8a1852ee3d1ecc7a29c23259b8c328a95030a270b7c11f37f22049177898652e
+  data.tar.gz: 56823f1815d3c0c4d5d5c01ef76d781b792b3e4e7c68c0332a149b883a54c7c8
 SHA512:
-  metadata.gz: acb727d9836709e5db4df21aeb6eec401e10f3c1910f95877493a9b1920cef4a0bd4914b906dab9b2ec18071fe95bf50de91a8a00a0914f3876ecb851e1c19c7
-  data.tar.gz: 7e69bde091825d7dcda81cfcfebd220c8072442322071a73eafd2849d9a899229bbcc2ce2b80f78e4b44e468e7a263ec83fd9a3fb3c1bf3073573596f40ec143
+  metadata.gz: bed15510cfeaa555d71f1e1f46ed8944893bd349a07c4316dcd63429fe76e13facd8794399ef97fc400d05796579f2e84822b62c98c71dc996e211ad04113ae2
+  data.tar.gz: aa05e3645e363eda27274323cdb7fb316342074d1d5afe8f7ee6bfd9819da7883b43d084beb6b29011c631c04fdddc8e6789db41c7c84c53ba9ed152d3338b09

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.3.7 (2020-09-22)
+
+- Improved performance
+- Added `Upsample`
+- Added support for passing tensor class to `type` method
+- Fixed error with buffers on GPU
+- Fixed error with `new_full`
+- Fixed issue with `numo` method and non-contiguous tensors
+
 ## 0.3.6 (2020-09-17)
 
 - Added `inplace` option for leaky ReLU

data/README.md

@@ -402,6 +402,7 @@ Here are a few full examples:
 - [Image classification with MNIST](examples/mnist) ([日本語版](https://qiita.com/kojix2/items/c19c36dc1bf73ea93409))
 - [Collaborative filtering with MovieLens](examples/movielens)
 - [Sequence models and word embeddings](examples/nlp)
+- [Generative adversarial networks](examples/gan)
 
 ## LibTorch Installation
 

data/ext/torch/ext.cpp

@@ -232,7 +232,7 @@ void Init_ext()
       })
     .define_singleton_method(
       "_empty",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::empty(size, options);
       })
     .define_singleton_method(
@@ -242,7 +242,7 @@ void Init_ext()
       })
     .define_singleton_method(
       "_full",
-      *[](IntArrayRef size, Scalar fill_value, const torch::TensorOptions& options) {
+      *[](std::vector<int64_t> size, Scalar fill_value, const torch::TensorOptions& options) {
         return torch::full(size, fill_value, options);
       })
     .define_singleton_method(
@@ -257,22 +257,22 @@ void Init_ext()
       })
     .define_singleton_method(
       "_ones",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::ones(size, options);
       })
     .define_singleton_method(
       "_rand",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::rand(size, options);
       })
     .define_singleton_method(
       "_randint",
-      *[](int64_t low, int64_t high, IntArrayRef size, const torch::TensorOptions &options) {
+      *[](int64_t low, int64_t high, std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::randint(low, high, size, options);
       })
     .define_singleton_method(
       "_randn",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::randn(size, options);
       })
     .define_singleton_method(
@@ -282,7 +282,7 @@ void Init_ext()
       })
     .define_singleton_method(
       "_zeros",
-      *[](IntArrayRef size, const torch::TensorOptions &options) {
+      *[](std::vector<int64_t> size, const torch::TensorOptions &options) {
         return torch::zeros(size, options);
       })
     // begin operations
@@ -303,13 +303,13 @@ void Init_ext()
       })
     .define_singleton_method(
       "_from_blob",
-      *[](String s, IntArrayRef size, const torch::TensorOptions &options) {
+      *[](String s, std::vector<int64_t> size, const torch::TensorOptions &options) {
         void *data = const_cast<char *>(s.c_str());
         return torch::from_blob(data, size, options);
       })
     .define_singleton_method(
       "_tensor",
-      *[](Array a, IntArrayRef size, const torch::TensorOptions &options) {
+      *[](Array a, std::vector<int64_t> size, const torch::TensorOptions &options) {
         auto dtype = options.dtype();
         torch::Tensor t;
         if (dtype == torch::kBool) {
@@ -342,6 +342,16 @@ void Init_ext()
     .define_method("numel", &torch::Tensor::numel)
     .define_method("element_size", &torch::Tensor::element_size)
     .define_method("requires_grad", &torch::Tensor::requires_grad)
+    // in C++ for performance
+    .define_method(
+      "shape",
+      *[](Tensor& self) {
+        Array a;
+        for (auto &size : self.sizes()) {
+          a.push(size);
+        }
+        return a;
+      })
     .define_method(
       "_index",
       *[](Tensor& self, Array indices) {
@@ -420,9 +430,19 @@ void Init_ext()
           tensor = tensor.to(device);
         }
 
+        if (!tensor.is_contiguous()) {
+          tensor = tensor.contiguous();
+        }
+
         auto data_ptr = (const char *) tensor.data_ptr();
         return std::string(data_ptr, tensor.numel() * tensor.element_size());
       })
+    // for TorchVision
+    .define_method(
+      "_data_ptr",
+      *[](Tensor& self) {
+        return reinterpret_cast<uintptr_t>(self.data_ptr());
+      })
     // TODO figure out a better way to do this
     .define_method(
       "_flat_data",

data/ext/torch/extconf.rb

@@ -17,6 +17,9 @@ if have_library("omp") || have_library("gomp")
 end
 
 if apple_clang
+  # silence rice warnings
+  $CXXFLAGS += " -Wno-deprecated-declarations"
+
   # silence ruby/intern.h warning
   $CXXFLAGS += " -Wno-deprecated-register"
 

data/ext/torch/templates.cpp

@@ -2,6 +2,34 @@
 #include <rice/Object.hpp>
 #include "templates.hpp"
 
+Object wrap(bool x) {
+  return to_ruby<bool>(x);
+}
+
+Object wrap(int64_t x) {
+  return to_ruby<int64_t>(x);
+}
+
+Object wrap(double x) {
+  return to_ruby<double>(x);
+}
+
+Object wrap(torch::Tensor x) {
+  return to_ruby<torch::Tensor>(x);
+}
+
+Object wrap(torch::Scalar x) {
+  return to_ruby<torch::Scalar>(x);
+}
+
+Object wrap(torch::ScalarType x) {
+  return to_ruby<torch::ScalarType>(x);
+}
+
+Object wrap(torch::QScheme x) {
+  return to_ruby<torch::QScheme>(x);
+}
+
 Object wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
   Array a;
   a.push(to_ruby<torch::Tensor>(std::get<0>(x)));

data/ext/torch/templates.hpp

@@ -13,49 +13,31 @@ using torch::Device;
 using torch::Scalar;
 using torch::ScalarType;
 using torch::Tensor;
-
-// need to wrap torch::IntArrayRef() since
-// it doesn't own underlying data
-class IntArrayRef {
-  std::vector<int64_t> vec;
-  public:
-    IntArrayRef(Object o) {
-      Array a = Array(o);
-      for (size_t i = 0; i < a.size(); i++) {
-        vec.push_back(from_ruby<int64_t>(a[i]));
-      }
-    }
-    operator torch::IntArrayRef() {
-      return torch::IntArrayRef(vec);
-    }
-};
+using torch::IntArrayRef;
+using torch::TensorList;
 
 template<>
 inline
-IntArrayRef from_ruby<IntArrayRef>(Object x)
+std::vector<int64_t> from_ruby<std::vector<int64_t>>(Object x)
 {
-  return IntArrayRef(x);
+  Array a = Array(x);
+  std::vector<int64_t> vec(a.size());
+  for (size_t i = 0; i < a.size(); i++) {
+    vec[i] = from_ruby<int64_t>(a[i]);
+  }
+  return vec;
 }
 
-class TensorList {
-  std::vector<torch::Tensor> vec;
-  public:
-    TensorList(Object o) {
-      Array a = Array(o);
-      for (size_t i = 0; i < a.size(); i++) {
-        vec.push_back(from_ruby<torch::Tensor>(a[i]));
-      }
-    }
-    operator torch::TensorList() {
-      return torch::TensorList(vec);
-    }
-};
-
 template<>
 inline
-TensorList from_ruby<TensorList>(Object x)
+std::vector<Tensor> from_ruby<std::vector<Tensor>>(Object x)
 {
-  return TensorList(x);
+  Array a = Array(x);
+  std::vector<Tensor> vec(a.size());
+  for (size_t i = 0; i < a.size(); i++) {
+    vec[i] = from_ruby<Tensor>(a[i]);
+  }
+  return vec;
 }
 
 class FanModeType {
@@ -242,6 +224,13 @@ torch::optional<Scalar> from_ruby<torch::optional<Scalar>>(Object x)
   }
 }
 
+Object wrap(bool x);
+Object wrap(int64_t x);
+Object wrap(double x);
+Object wrap(torch::Tensor x);
+Object wrap(torch::Scalar x);
+Object wrap(torch::ScalarType x);
+Object wrap(torch::QScheme x);
 Object wrap(std::tuple<torch::Tensor, torch::Tensor> x);
 Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x);
 Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x);

data/lib/torch.rb

@@ -174,6 +174,9 @@ require "torch/nn/smooth_l1_loss"
 require "torch/nn/soft_margin_loss"
 require "torch/nn/triplet_margin_loss"
 
+# nn vision
+require "torch/nn/upsample"
+
 # nn other
 require "torch/nn/functional"
 require "torch/nn/init"
@@ -196,6 +199,32 @@ module Torch
     end
   end
 
+  # legacy
+  # but may make it easier to port tutorials
+  module Autograd
+    class Variable
+      def self.new(x)
+        raise ArgumentError, "Variable data has to be a tensor, but got #{x.class.name}" unless x.is_a?(Tensor)
+        warn "[torch] The Variable API is deprecated. Use tensors with requires_grad: true instead."
+        x
+      end
+    end
+  end
+
+  # TODO move to C++
+  class ByteStorage
+    # private
+    attr_reader :bytes
+
+    def initialize(bytes)
+      @bytes = bytes
+    end
+
+    def self.from_buffer(bytes)
+      new(bytes)
+    end
+  end
+
   # keys: https://pytorch.org/docs/stable/tensor_attributes.html#torch.torch.dtype
   # values: https://github.com/pytorch/pytorch/blob/master/c10/core/ScalarType.h
   DTYPE_TO_ENUM = {
@@ -224,18 +253,24 @@ module Torch
   }
   ENUM_TO_DTYPE = DTYPE_TO_ENUM.map(&:reverse).to_h
 
+  TENSOR_TYPE_CLASSES = []
+
   def self._make_tensor_class(dtype, cuda = false)
     cls = Class.new
     device = cuda ? "cuda" : "cpu"
     cls.define_singleton_method("new") do |*args|
       if args.size == 1 && args.first.is_a?(Tensor)
         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]))
       elsif args.size == 1 && args.first.is_a?(Array)
         Torch.tensor(args.first, dtype: dtype, device: device)
       else
         Torch.empty(*args, dtype: dtype, device: device)
       end
     end
+    TENSOR_TYPE_CLASSES << cls
     cls
   end
 

data/lib/torch/native/dispatcher.rb

@@ -22,21 +22,43 @@ module Torch
         end
 
         def bind_functions(context, def_method, functions)
+          instance_method = def_method == :define_method
           functions.group_by(&:ruby_name).sort_by { |g, _| g }.each do |name, funcs|
-            if def_method == :define_method
+            if instance_method
               funcs.map! { |f| Function.new(f.function) }
-              funcs.each { |f| f.args.reject! { |a| a[:name] == "self" } }
+              funcs.each { |f| f.args.reject! { |a| a[:name] == :self } }
             end
 
-            defined = def_method == :define_method ? context.method_defined?(name) : context.respond_to?(name)
+            defined = instance_method ? context.method_defined?(name) : context.respond_to?(name)
             next if defined && name != "clone"
 
-            parser = Parser.new(funcs)
+            # skip parser when possible for performance
+            if funcs.size == 1 && funcs.first.args.size == 0
+              # functions with no arguments
+              if instance_method
+                context.send(:alias_method, name, funcs.first.cpp_name)
+              else
+                context.singleton_class.send(:alias_method, name, funcs.first.cpp_name)
+              end
+            elsif funcs.size == 2 && funcs.map { |f| f.arg_types.values }.sort == [["Scalar"], ["Tensor"]]
+              # functions that take a tensor or scalar
+              scalar_name, tensor_name = funcs.sort_by { |f| f.arg_types.values }.map(&:cpp_name)
+              context.send(def_method, name) do |other|
+                case other
+                when Tensor
+                  send(tensor_name, other)
+                else
+                  send(scalar_name, other)
+                end
+              end
+            else
+              parser = Parser.new(funcs)
 
-            context.send(def_method, name) do |*args, **options|
-              result = parser.parse(args, options)
-              raise ArgumentError, result[:error] if result[:error]
-              send(result[:name], *result[:args])
+              context.send(def_method, name) do |*args, **options|
+                result = parser.parse(args, options)
+                raise ArgumentError, result[:error] if result[:error]
+                send(result[:name], *result[:args])
+              end
             end
           end
         end

data/lib/torch/native/function.rb

@@ -6,9 +6,10 @@ module Torch
       def initialize(function)
         @function = function
 
-        tensor_options_str = ", *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None)"
-        @tensor_options = @function["func"].include?(tensor_options_str)
-        @function["func"].sub!(tensor_options_str, ")")
+        # note: don't modify function in-place
+        @tensor_options_str = ", *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None)"
+        @tensor_options = @function["func"].include?(@tensor_options_str)
+        @out = out_size > 0 && base_name[-1] != "_"
       end
 
       def func
@@ -31,7 +32,7 @@ module Torch
         @args ||= begin
           args = []
           pos = true
-          args_str = func.split("(", 2).last.split(") ->").first
+          args_str = func.sub(@tensor_options_str, ")").split("(", 2).last.split(") ->").first
           args_str.split(", ").each do |a|
             if a == "*"
               pos = false
@@ -72,12 +73,88 @@ module Torch
             next if t == "Generator?"
             next if t == "MemoryFormat"
             next if t == "MemoryFormat?"
-            args << {name: k, type: t, default: d, pos: pos, has_default: has_default}
+            args << {name: k.to_sym, type: t, default: d, pos: pos, has_default: has_default}
           end
           args
         end
       end
 
+      def arg_checkers
+        @arg_checkers ||= begin
+          checkers = {}
+          arg_types.each do |k, t|
+            checker =
+              case t
+              when "Tensor"
+                ->(v) { v.is_a?(Tensor) }
+              when "Tensor?"
+                ->(v) { v.nil? || v.is_a?(Tensor) }
+              when "Tensor[]", "Tensor?[]"
+                ->(v) { v.is_a?(Array) && v.all? { |v2| v2.is_a?(Tensor) } }
+              when "int"
+                if k == :reduction
+                  ->(v) { v.is_a?(String) }
+                else
+                  ->(v) { v.is_a?(Integer) }
+                end
+              when "int?"
+                ->(v) { v.is_a?(Integer) || v.nil? }
+              when "float?"
+                ->(v) { v.is_a?(Numeric) || v.nil? }
+              when "bool?"
+                ->(v) { v == true || v == false || v.nil? }
+              when "float"
+                ->(v) { v.is_a?(Numeric) }
+              when /int\[.*\]/
+                ->(v) { v.is_a?(Array) && v.all? { |v2| v2.is_a?(Integer) } }
+              when "Scalar"
+                ->(v) { v.is_a?(Numeric) }
+              when "Scalar?"
+                ->(v) { v.is_a?(Numeric) || v.nil? }
+              when "ScalarType"
+                ->(v) { false } # not supported yet
+              when "ScalarType?"
+                ->(v) { v.nil? }
+              when "bool"
+                ->(v) { v == true || v == false }
+              when "str"
+                ->(v) { v.is_a?(String) }
+              else
+                raise Error, "Unknown argument type: #{t}. Please report a bug with #{@name}."
+              end
+            checkers[k] = checker
+          end
+          checkers
+        end
+      end
+
+      def int_array_lengths
+        @int_array_lengths ||= begin
+          ret = {}
+          arg_types.each do |k, t|
+            if t.match?(/\Aint\[.+\]\z/)
+              size = t[4..-2]
+              raise Error, "Unknown size: #{size}. Please report a bug with #{@name}." unless size =~ /\A\d+\z/
+              ret[k] = size.to_i
+            end
+          end
+          ret
+        end
+      end
+
+      def arg_names
+        @arg_names ||= args.map { |a| a[:name] }
+      end
+
+      def arg_types
+        @arg_types ||= args.map { |a| [a[:name], a[:type].split("(").first] }.to_h
+      end
+
+      def arg_defaults
+        # TODO find out why can't use select here
+        @arg_defaults ||= args.map { |a| [a[:name], a[:default]] }.to_h
+      end
+
       def out_size
         @out_size ||= func.split("->").last.count("!")
       end
@@ -90,8 +167,12 @@ module Torch
         @ret_array ||= func.split("->").last.include?('[]')
       end
 
+      def ret_void?
+        func.split("->").last.strip == "()"
+      end
+
       def out?
-        out_size > 0 && base_name[-1] != "_"
+        @out
       end
 
       def ruby_name

data/lib/torch/native/generator.rb

@@ -72,16 +72,18 @@ void add_%{type}_functions(Module m);
 #include <rice/Module.hpp>
 #include "templates.hpp"
 
+%{functions}
+
 void add_%{type}_functions(Module m) {
-  m
-  %{functions};
+  %{add_functions}
 }
         TEMPLATE
 
           cpp_defs = []
+          add_defs = []
           functions.sort_by(&:cpp_name).each do |func|
             fargs = func.args.dup #.select { |a| a[:type] != "Generator?" }
-            fargs << {name: "options", type: "TensorOptions"} if func.tensor_options
+            fargs << {name: :options, type: "TensorOptions"} if func.tensor_options
 
             cpp_args = []
             fargs.each do |a|
@@ -94,11 +96,9 @@ void add_%{type}_functions(Module m) {
                   "OptionalTensor"
                 when "ScalarType?"
                   "torch::optional<ScalarType>"
-                when "Tensor[]"
-                  "TensorList"
-                when "Tensor?[]"
+                when "Tensor[]", "Tensor?[]"
                   # TODO make optional
-                  "TensorList"
+                  "std::vector<Tensor>"
                 when "int"
                   "int64_t"
                 when "int?"
@@ -112,43 +112,53 @@ void add_%{type}_functions(Module m) {
                 when "float"
                   "double"
                 when /\Aint\[/
-                  "IntArrayRef"
+                  "std::vector<int64_t>"
                 when /Tensor\(\S!?\)/
                   "Tensor &"
                 when "str"
                   "std::string"
                 when "TensorOptions"
                   "const torch::TensorOptions &"
-                else
+                when "Layout?"
+                  "torch::optional<Layout>"
+                when "Device?"
+                  "torch::optional<Device>"
+                when "Scalar", "bool", "ScalarType", "Layout", "Device", "Storage"
                   a[:type]
+                else
+                  raise "Unknown type: #{a[:type]}"
                 end
 
-              t = "MyReduction" if a[:name] == "reduction" && t == "int64_t"
+              t = "MyReduction" if a[:name] == :reduction && t == "int64_t"
               cpp_args << [t, a[:name]].join(" ").sub("& ", "&")
             end
 
             dispatch = func.out? ? "#{func.base_name}_out" : func.base_name
             args = fargs.map { |a| a[:name] }
             args.unshift(*args.pop(func.out_size)) if func.out?
-            args.delete("self") if def_method == :define_method
+            args.delete(:self) if def_method == :define_method
 
             prefix = def_method == :define_method ? "self." : "torch::"
 
             body = "#{prefix}#{dispatch}(#{args.join(", ")})"
 
-            if func.ret_size > 1 || func.ret_array?
+            if func.cpp_name == "_fill_diagonal_"
+              body = "to_ruby<torch::Tensor>(#{body})"
+            elsif !func.ret_void?
               body = "wrap(#{body})"
             end
 
-            cpp_defs << ".#{def_method}(
-    \"#{func.cpp_name}\",
-    *[](#{cpp_args.join(", ")}) {
-      return #{body};
-    })"
+            cpp_defs << "// #{func.func}
+static #{func.ret_void? ? "void" : "Object"} #{type}#{func.cpp_name}(#{cpp_args.join(", ")})
+{
+  return #{body};
+}"
+
+            add_defs << "m.#{def_method}(\"#{func.cpp_name}\", #{type}#{func.cpp_name});"
           end
 
           hpp_contents = hpp_template % {type: type}
-          cpp_contents = cpp_template % {type: type, functions: cpp_defs.join("\n  ")}
+          cpp_contents = cpp_template % {type: type, functions: cpp_defs.join("\n\n"), add_functions: add_defs.join("\n  ")}
 
           path = File.expand_path("../../../ext/torch", __dir__)
           File.write("#{path}/#{type}_functions.hpp", hpp_contents)

data/lib/torch/native/parser.rb

@@ -6,14 +6,24 @@ module Torch
         @name = @functions.first.ruby_name
         @min_args = @functions.map { |f| f.args.count { |a| a[:pos] && !a[:has_default] } }.min
         @max_args = @functions.map { |f| f.args.count { |a| a[:pos] } }.max
+        @int_array_first = @functions.all? { |c| c.args.first && c.args.first[:type] == "int[]" }
       end
 
+      # TODO improve performance
+      # possibly move to C++ (see python_arg_parser.cpp)
       def parse(args, options)
         candidates = @functions.dup
 
-        # remove nil
-        while args.any? && args.last.nil?
-          args.pop
+        # TODO check candidates individually to see if they match
+        if @int_array_first
+          int_args = []
+          while args.first.is_a?(Integer)
+            int_args << args.shift
+          end
+          if int_args.any?
+            raise ArgumentError, "argument '#{candidates.first.args.first[:name]}' must be array of ints, but found element of type #{args.first.class.name} at pos #{int_args.size + 1}" if args.any?
+            args.unshift(int_args)
+          end
         end
 
         # TODO account for args passed as options here
@@ -25,99 +35,60 @@ module Torch
 
         candidates.reject! { |f| args.size > f.args.size }
 
-        # exclude functions missing required options
-        candidates.reject! do |func|
-          # TODO make more generic
-          func.out? && !options[:out]
-        end
-
         # handle out with multiple
         # there should only be one match, so safe to modify all
-        out_func = candidates.find { |f| f.out? }
-        if out_func && out_func.out_size > 1 && options[:out]
-          out_args = out_func.args.last(2).map { |a| a[:name] }
-          out_args.zip(options.delete(:out)).each do |k, v|
-            options[k.to_sym] = v
-          end
-          candidates = [out_func]
-        end
-
-        # exclude functions where options don't match
-        options.each do |k, v|
-          candidates.select! do |func|
-            func.args.any? { |a| a[:name] == k.to_s }
+        if options[:out]
+          if (out_func = candidates.find { |f| f.out? }) && out_func.out_size > 1
+            out_args = out_func.args.last(2).map { |a| a[:name] }
+            out_args.zip(options.delete(:out)).each do |k, v|
+              options[k] = v
+            end
+            candidates = [out_func]
           end
-          # TODO show all bad keywords at once like Ruby?
-          return {error: "unknown keyword: #{k}"} if candidates.empty?
+        else
+          # exclude functions missing required options
+          candidates.reject!(&:out?)
         end
 
-        final_values = {}
+        final_values = nil
 
         # check args
-        candidates.select! do |func|
+        while (func = candidates.shift)
           good = true
 
-          values = args.zip(func.args).map { |a, fa| [fa[:name], a] }.to_h
-          values.merge!(options.map { |k, v| [k.to_s, v] }.to_h)
-          func.args.each do |fa|
-            values[fa[:name]] = fa[:default] if values[fa[:name]].nil?
+          # set values
+          # TODO use array instead of hash?
+          values = {}
+          args.each_with_index do |a, i|
+            values[func.arg_names[i]] = a
+          end
+          options.each do |k, v|
+            values[k] = v
+          end
+          func.arg_defaults.each do |k, v|
+            values[k] = v unless values.key?(k)
+          end
+          func.int_array_lengths.each do |k, len|
+            values[k] = [values[k]] * len if values[k].is_a?(Integer)
           end
 
-          arg_types = func.args.map { |a| [a[:name], a[:type]] }.to_h
+          arg_checkers = func.arg_checkers
 
           values.each_key do |k|
-            v = values[k]
-            t = arg_types[k].split("(").first
-
-            good =
-              case t
-              when "Tensor"
-                v.is_a?(Tensor)
-              when "Tensor?"
-                v.nil? || v.is_a?(Tensor)
-              when "Tensor[]", "Tensor?[]"
-                v.is_a?(Array) && v.all? { |v2| v2.is_a?(Tensor) }
-              when "int"
-                if k == "reduction"
-                  v.is_a?(String)
-                else
-                  v.is_a?(Integer)
-                end
-              when "int?"
-                v.is_a?(Integer) || v.nil?
-              when "float?"
-                v.is_a?(Numeric) || v.nil?
-              when "bool?"
-                v == true || v == false || v.nil?
-              when "float"
-                v.is_a?(Numeric)
-              when /int\[.*\]/
-                if v.is_a?(Integer)
-                  size = t[4..-2]
-                  raise Error, "Unknown size: #{size}. Please report a bug with #{@name}." unless size =~ /\A\d+\z/
-                  v = [v] * size.to_i
-                  values[k] = v
-                end
-                v.is_a?(Array) && v.all? { |v2| v2.is_a?(Integer) }
-              when "Scalar"
-                v.is_a?(Numeric)
-              when "Scalar?"
-                v.is_a?(Numeric) || v.nil?
-              when "ScalarType"
-                false # not supported yet
-              when "ScalarType?"
-                v.nil?
-              when "bool"
-                v == true || v == false
-              when "str"
-                v.is_a?(String)
-              else
-                raise Error, "Unknown argument type: #{arg_types[k]}. Please report a bug with #{@name}."
+            unless arg_checkers.key?(k)
+              good = false
+              if candidates.empty?
+                # TODO show all bad keywords at once like Ruby?
+                return {error: "unknown keyword: #{k}"}
               end
+              break
+            end
 
-            if !good
-              if candidates.size == 1
-                k = "input" if k == "self"
+            unless arg_checkers[k].call(values[k])
+              good = false
+              if candidates.empty?
+                t = func.arg_types[k]
+                k = :input if k == :self
                 return {error: "#{@name}(): argument '#{k}' must be #{t}"}
               end
               break
@@ -126,17 +97,15 @@ module Torch
 
           if good
             final_values = values
+            break
           end
-
-          good
         end
 
-        if candidates.size != 1
+        unless final_values
           raise Error, "This should never happen. Please report a bug with #{@name}."
         end
 
-        func = candidates.first
-        args = func.args.map { |a| final_values[a[:name]] }
+        args = func.arg_names.map { |k| final_values[k] }
         args << TensorOptions.new.dtype(6) if func.tensor_options
         {
           name: func.cpp_name,

data/lib/torch/nn/functional.rb

@@ -469,6 +469,77 @@ module Torch
           Torch.triplet_margin_loss(anchor, positive, negative, margin, p, eps, swap, reduction)
         end
 
+        # vision
+
+        def interpolate(input, size: nil, scale_factor: nil, mode: "nearest", align_corners: nil, recompute_scale_factor: nil)
+          if ["nearest", "area"].include?(mode)
+            unless align_corners.nil?
+              raise ArgumentError, "align_corners option can only be set with the interpolating modes: linear | bilinear | bicubic | trilinear"
+            end
+          else
+            if align_corners.nil?
+              align_corners = false
+            end
+          end
+
+          scale_factor_len = input.dim - 2
+          scale_factor_list = [nil] * scale_factor_len
+          # default value of recompute_scale_factor is False
+          if !scale_factor.nil? && (recompute_scale_factor == false || recompute_scale_factor.nil?)
+            if scale_factor.is_a?(Array)
+              _scale_factor_repeated = scale_factor
+            else
+              _scale_factor_repeated = [scale_factor] * scale_factor_len
+            end
+            scale_factor_list = _scale_factor_repeated
+          end
+
+          # Give this variable a short name because it has to be repeated multiple times below.
+          sfl = scale_factor_list
+
+          closed_over_args = [input, size, scale_factor, recompute_scale_factor]
+          output_size = _interp_output_size(closed_over_args)
+          if input.dim == 3 && mode == "nearest"
+            NN.upsample_nearest1d(input, output_size, sfl[0])
+          elsif input.dim == 4 && mode == "nearest"
+            NN.upsample_nearest2d(input, output_size, sfl[0], sfl[1])
+          elsif input.dim == 5 && mode == "nearest"
+            NN.upsample_nearest3d(input, output_size, sfl[0], sfl[1], sfl[2])
+          elsif input.dim == 3 && mode == "area"
+            adaptive_avg_pool1d(input, output_size)
+          elsif input.dim == 4 && mode == "area"
+            adaptive_avg_pool2d(input, output_size)
+          elsif input.dim == 5 && mode == "area"
+            adaptive_avg_pool3d(input, output_size)
+          elsif input.dim == 3 && mode == "linear"
+            # assert align_corners is not None
+            NN.upsample_linear1d(input, output_size, align_corners, sfl[0])
+          elsif input.dim == 3 && mode == "bilinear"
+            raise ArgumentError, "Got 3D input, but bilinear mode needs 4D input"
+          elsif input.dim == 3 && mode == "trilinear"
+            raise ArgumentError, "Got 3D input, but trilinear mode needs 5D input"
+          elsif input.dim == 4 && mode == "linear"
+            raise ArgumentError, "Got 4D input, but linear mode needs 3D input"
+          elsif input.dim == 4 && mode == "bilinear"
+            # assert align_corners is not None
+            NN.upsample_bilinear2d(input, output_size, align_corners, sfl[0], sfl[1])
+          elsif input.dim == 4 && mode == "trilinear"
+            raise ArgumentError, "Got 4D input, but trilinear mode needs 5D input"
+          elsif input.dim == 5 && mode == "linear"
+            raise ArgumentError, "Got 5D input, but linear mode needs 3D input"
+          elsif input.dim == 5 && mode == "bilinear"
+            raise ArgumentError, "Got 5D input, but bilinear mode needs 4D input"
+          elsif input.dim == 5 && mode == "trilinear"
+            # assert align_corners is not None
+            NN.upsample_trilinear3d(input, output_size, align_corners, sfl[0], sfl[1], sfl[2])
+          elsif input.dim == 4 && mode == "bicubic"
+            # assert align_corners is not None
+            NN.upsample_bicubic2d(input, output_size, align_corners, sfl[0], sfl[1])
+          else
+            raise ArgumentError, "Input Error: Only 3D, 4D and 5D input Tensors supported (got #{input.dim}D) for the modes: nearest | linear | bilinear | bicubic | trilinear (got #{mode})"
+          end
+        end
+
         private
 
         def softmax_dim(ndim)
@@ -484,6 +555,41 @@ module Torch
             out_size.zip(defaults.last(out_size.length)).map { |v, d| v || d }
           end
         end
+
+        def _interp_output_size(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"
+          end
+          if !size.nil? && !scale_factor.nil?
+            raise ArgumentError, "only one of size or scale_factor should be defined"
+          end
+          if !scale_factor.nil?
+            if scale_factor.is_a?(Array)
+              if scale_factor.length != dim
+                raise ArgumentError, "scale_factor shape must match input shape. Input is #{dim}D, scale_factor size is #{scale_factor.length}"
+              end
+            end
+          end
+
+          if !size.nil?
+            if size.is_a?(Array)
+              return size
+            else
+              return [size] * dim
+            end
+          end
+
+          raise "Failed assertion" if scale_factor.nil?
+          if scale_factor.is_a?(Array)
+            scale_factors = scale_factor
+          else
+            scale_factors = [scale_factor] * dim
+          end
+
+          dim.times.map { |i| (input.size(i + 2) * scale_factors[i]).floor }
+        end
       end
     end
 

data/lib/torch/nn/module.rb

@@ -58,7 +58,10 @@ module Torch
 
         @buffers.each_key do |k|
           buf = @buffers[k]
-          @buffers[k] = fn.call(buf) unless buf.nil?
+          unless buf.nil?
+            @buffers[k] = fn.call(buf)
+            instance_variable_set("@#{k}", @buffers[k])
+          end
         end
 
         self

data/lib/torch/nn/upsample.rb

@@ -0,0 +1,31 @@
+module Torch
+  module NN
+    class Upsample < Module
+      def initialize(size: nil, scale_factor: nil, mode: "nearest", align_corners: nil)
+        super()
+        @size = size
+        if scale_factor.is_a?(Array)
+          @scale_factor = scale_factor.map(&:to_f)
+        else
+          @scale_factor = scale_factor ? scale_factor.to_f : nil
+        end
+        @mode = mode
+        @align_corners = align_corners
+      end
+
+      def forward(input)
+        F.interpolate(input, size: @size, scale_factor: @scale_factor, mode: @mode, align_corners: @align_corners)
+      end
+
+      def extra_inspect
+        if !@scale_factor.nil?
+          info = "scale_factor: #{@scale_factor.inspect}"
+        else
+          info = "size: #{@size.inspect}"
+        end
+        info += ", mode: #{@mode.inspect}"
+        info
+      end
+    end
+  end
+end

data/lib/torch/tensor.rb

@@ -48,6 +48,11 @@ module Torch
     end
 
     def to(device = nil, dtype: nil, non_blocking: false, copy: false)
+      if device.is_a?(Symbol) && !dtype
+        dtype = device
+        device = nil
+      end
+
       device ||= self.device
       device = Device.new(device) if device.is_a?(String)
 
@@ -74,10 +79,6 @@ module Torch
       end
     end
 
-    def shape
-      dim.times.map { |i| size(i) }
-    end
-
     # mirror Python len()
     def length
       size(0)
@@ -119,9 +120,14 @@ module Torch
     end
 
     def type(dtype)
-      enum = DTYPE_TO_ENUM[dtype]
-      raise Error, "Unknown type: #{dtype}" unless enum
-      _type(enum)
+      if dtype.is_a?(Class)
+        raise Error, "Invalid type: #{dtype}" unless TENSOR_TYPE_CLASSES.include?(dtype)
+        dtype.new(self)
+      else
+        enum = DTYPE_TO_ENUM[dtype]
+        raise Error, "Invalid type: #{dtype}" unless enum
+        _type(enum)
+      end
     end
 
     def reshape(*size)

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.3.6"
+  VERSION = "0.3.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-18 00:00:00.000000000 Z
+date: 2020-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -238,6 +238,7 @@ files:
 - lib/torch/nn/tanhshrink.rb
 - lib/torch/nn/triplet_margin_loss.rb
 - lib/torch/nn/unfold.rb
+- lib/torch/nn/upsample.rb
 - lib/torch/nn/utils.rb
 - lib/torch/nn/weighted_loss.rb
 - lib/torch/nn/zero_pad2d.rb