torch-rb 0.3.7 → 0.4.0

data/lib/torch/tensor.rb

@@ -8,6 +8,18 @@ module Torch
     alias_method :ndim, :dim
     alias_method :ndimension, :dim
 
+    # use alias_method for performance
+    alias_method :+, :add
+    alias_method :-, :sub
+    alias_method :*, :mul
+    alias_method :/, :div
+    alias_method :%, :remainder
+    alias_method :**, :pow
+    alias_method :-@, :neg
+    alias_method :&, :logical_and
+    alias_method :|, :logical_or
+    alias_method :^, :logical_xor
+
     def self.new(*args)
       FloatTensor.new(*args)
     end
@@ -73,12 +85,20 @@ module Torch
 
     def size(dim = nil)
       if dim
-        _size_int(dim)
+        _size(dim)
       else
         shape
       end
     end
 
+    def stride(dim = nil)
+      if dim
+        _stride(dim)
+      else
+        _strides
+      end
+    end
+
     # mirror Python len()
     def length
       size(0)
@@ -130,57 +150,6 @@ module Torch
       end
     end
 
-    def reshape(*size)
-      # Python doesn't check if size == 1, just ignores later arguments
-      size = size.first if size.size == 1 && size.first.is_a?(Array)
-      _reshape(size)
-    end
-
-    def view(*size)
-      size = size.first if size.size == 1 && size.first.is_a?(Array)
-      _view(size)
-    end
-
-    def +(other)
-      add(other)
-    end
-
-    def -(other)
-      sub(other)
-    end
-
-    def *(other)
-      mul(other)
-    end
-
-    def /(other)
-      div(other)
-    end
-
-    def %(other)
-      remainder(other)
-    end
-
-    def **(other)
-      pow(other)
-    end
-
-    def -@
-      neg
-    end
-
-    def &(other)
-      logical_and(other)
-    end
-
-    def |(other)
-      logical_or(other)
-    end
-
-    def ^(other)
-      logical_xor(other)
-    end
-
     # TODO better compare?
     def <=>(other)
       item <=> other
@@ -189,7 +158,7 @@ module Torch
     # based on python_variable_indexing.cpp and
     # https://pytorch.org/cppdocs/notes/tensor_indexing.html
     def [](*indexes)
-      _index(tensor_indexes(indexes))
+      _index(indexes)
     end
 
     # based on python_variable_indexing.cpp and
@@ -197,62 +166,13 @@ module Torch
     def []=(*indexes, value)
       raise ArgumentError, "Tensor does not support deleting items" if value.nil?
       value = Torch.tensor(value, dtype: dtype) unless value.is_a?(Tensor)
-      _index_put_custom(tensor_indexes(indexes), value)
-    end
-
-    # native functions that need manually defined
-
-    # value and other are swapped for some methods
-    def add!(value = 1, other)
-      if other.is_a?(Numeric)
-        _add__scalar(other, value)
-      else
-        _add__tensor(other, value)
-      end
+      _index_put_custom(indexes, value)
     end
 
     # parser can't handle overlap, so need to handle manually
     def random!(*args)
-      case args.size
-      when 1
-        _random__to(*args)
-      when 2
-        _random__from(*args)
-      else
-        _random_(*args)
-      end
-    end
-
-    def clamp!(min, max)
-      _clamp_min_(min)
-      _clamp_max_(max)
-    end
-
-    private
-
-    def tensor_indexes(indexes)
-      indexes.map do |index|
-        case index
-        when Integer
-          TensorIndex.integer(index)
-        when Range
-          finish = index.end || -1
-          if finish == -1 && !index.exclude_end?
-            finish = nil
-          else
-            finish += 1 unless index.exclude_end?
-          end
-          TensorIndex.slice(index.begin, finish)
-        when Tensor
-          TensorIndex.tensor(index)
-        when nil
-          TensorIndex.none
-        when true, false
-          TensorIndex.boolean(index)
-        else
-          raise Error, "Unsupported index type: #{index.class.name}"
-        end
-      end
+      return _random!(0, *args) if args.size == 1
+      _random!(*args)
     end
   end
 end

data/lib/torch/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.4.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-23 00:00:00.000000000 Z
+date: 2020-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: magro
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: andrew@chartkick.com
 executables: []
@@ -118,19 +132,23 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- codegen/function.rb
+- codegen/generate_functions.rb
+- codegen/native_functions.yaml
 - ext/torch/ext.cpp
 - ext/torch/extconf.rb
-- ext/torch/templates.cpp
-- ext/torch/templates.hpp
+- ext/torch/nn_functions.h
+- ext/torch/ruby_arg_parser.cpp
+- ext/torch/ruby_arg_parser.h
+- ext/torch/templates.h
+- ext/torch/tensor_functions.h
+- ext/torch/torch_functions.h
+- ext/torch/utils.h
+- ext/torch/wrap_outputs.h
 - lib/torch-rb.rb
 - lib/torch.rb
 - lib/torch/hub.rb
 - lib/torch/inspector.rb
-- lib/torch/native/dispatcher.rb
-- lib/torch/native/function.rb
-- lib/torch/native/generator.rb
-- lib/torch/native/native_functions.yaml
-- lib/torch/native/parser.rb
 - lib/torch/nn/adaptive_avg_pool1d.rb
 - lib/torch/nn/adaptive_avg_pool2d.rb
 - lib/torch/nn/adaptive_avg_pool3d.rb

data/lib/torch/native/dispatcher.rb

@@ -1,70 +0,0 @@
-# We use a generic interface for methods (*args, **options)
-# and this class to determine the C++ method to call
-#
-# This is needed since LibTorch uses function overloading,
-# which isn't available in Ruby or Python
-#
-# PyTorch uses this approach, but the parser/dispatcher is written in C++
-#
-# We could generate Ruby methods directly, but an advantage of this approach is
-# arguments and keyword arguments can be used interchangably like in Python,
-# making it easier to port code
-
-module Torch
-  module Native
-    module Dispatcher
-      class << self
-        def bind
-          functions = Generator.grouped_functions
-          bind_functions(::Torch, :define_singleton_method, functions[:torch])
-          bind_functions(::Torch::Tensor, :define_method, functions[:tensor])
-          bind_functions(::Torch::NN, :define_singleton_method, functions[:nn])
-        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 instance_method
-              funcs.map! { |f| Function.new(f.function) }
-              funcs.each { |f| f.args.reject! { |a| a[:name] == :self } }
-            end
-
-            defined = instance_method ? context.method_defined?(name) : context.respond_to?(name)
-            next if defined && name != "clone"
-
-            # 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])
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-Torch::Native::Dispatcher.bind

data/lib/torch/native/function.rb

@@ -1,200 +0,0 @@
-module Torch
-  module Native
-    class Function
-      attr_reader :function, :tensor_options
-
-      def initialize(function)
-        @function = function
-
-        # 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
-        @func ||= @function["func"]
-      end
-
-      def name
-        @name ||= func.split("(", 2).first
-      end
-
-      def python_module
-        @python_module ||= @function["python_module"]
-      end
-
-      def variants
-        @variants ||= (@function["variants"] || "function").split(", ")
-      end
-
-      def args
-        @args ||= begin
-          args = []
-          pos = true
-          args_str = func.sub(@tensor_options_str, ")").split("(", 2).last.split(") ->").first
-          args_str.split(", ").each do |a|
-            if a == "*"
-              pos = false
-              next
-            end
-            t, _, k = a.rpartition(" ")
-            k, d = k.split("=")
-            has_default = !d.nil?
-
-            if d
-              d =
-                case d
-                when "True"
-                  true
-                when "False"
-                  false
-                when "None"
-                  nil
-                when /\A\-?\d+\z/
-                  d.to_i
-                when "[]"
-                  []
-                when "[0,1]"
-                  [0, 1]
-                when /\A\de\-\d+\z/, /\A\d+\.\d+\z/
-                  d.to_f
-                when "Mean"
-                  "mean"
-                when "contiguous_format"
-                  d
-                when "long"
-                  :long
-                else
-                  raise "Unknown default: #{d}"
-                end
-            end
-
-            next if t == "Generator?"
-            next if t == "MemoryFormat"
-            next if t == "MemoryFormat?"
-            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
-
-      def ret_size
-        @ret_size ||= func.split("->").last.split(", ").size
-      end
-
-      def ret_array?
-        @ret_array ||= func.split("->").last.include?('[]')
-      end
-
-      def ret_void?
-        func.split("->").last.strip == "()"
-      end
-
-      def out?
-        @out
-      end
-
-      def ruby_name
-        @ruby_name ||= begin
-          name = base_name
-          if name.end_with?("_")
-            "#{name[0..-2]}!"
-          elsif name.start_with?("is_")
-            "#{name[3..-1]}?"
-          else
-            name
-          end
-        end
-      end
-
-      def cpp_name
-        @cpp_name ||= "_" + name.downcase.sub(".", "_")
-      end
-
-      def base_name
-        @base_name ||= name.split(".").first
-      end
-    end
-  end
-end