torch-rb 0.3.7 → 0.5.1

data/lib/torch/optim/adam.rb

@@ -53,12 +53,12 @@ module Torch
             bias_correction2 = 1 - beta2 ** state[:step]
 
             if group[:weight_decay] != 0
-              grad.add!(group[:weight_decay], p.data)
+              grad.add!(p.data, alpha: group[:weight_decay])
             end
 
             # Decay the first and second moment running average coefficient
-            exp_avg.mul!(beta1).add!(1 - beta1, grad)
-            exp_avg_sq.mul!(beta2).addcmul!(1 - beta2, grad, grad)
+            exp_avg.mul!(beta1).add!(grad, alpha: 1 - beta1)
+            exp_avg_sq.mul!(beta2).addcmul!(grad, grad, value: 1 - beta2)
             if amsgrad
               # Maintains the maximum of all 2nd moment running avg. till now
               Torch.max(max_exp_avg_sq, exp_avg_sq, out: max_exp_avg_sq)
@@ -70,7 +70,7 @@ module Torch
 
             step_size = group[:lr] / bias_correction1
 
-            p.data.addcdiv!(-step_size, exp_avg, denom)
+            p.data.addcdiv!(exp_avg, denom, value: -step_size)
           end
         end
 

data/lib/torch/optim/adamax.rb

@@ -42,11 +42,11 @@ module Torch
             state[:step] += 1
 
             if group[:weight_decay] != 0
-              grad = grad.add(group[:weight_decay], p.data)
+              grad = grad.add(p.data, alpha: group[:weight_decay])
             end
 
             # Update biased first moment estimate.
-            exp_avg.mul!(beta1).add!(1 - beta1, grad)
+            exp_avg.mul!(beta1).add!(grad, alpha: 1 - beta1)
             # Update the exponentially weighted infinity norm.
             norm_buf = Torch.cat([
                 exp_inf.mul!(beta2).unsqueeze(0),
@@ -57,7 +57,7 @@ module Torch
             bias_correction = 1 - beta1 ** state[:step]
             clr = group[:lr] / bias_correction
 
-            p.data.addcdiv!(-clr, exp_avg, exp_inf)
+            p.data.addcdiv!(exp_avg, exp_inf, value: -clr)
           end
         end
 

data/lib/torch/optim/adamw.rb

@@ -58,8 +58,8 @@ module Torch
             bias_correction2 = 1 - beta2 ** state[:step]
 
             # Decay the first and second moment running average coefficient
-            exp_avg.mul!(beta1).add!(1 - beta1, grad)
-            exp_avg_sq.mul!(beta2).addcmul!(1 - beta2, grad, grad)
+            exp_avg.mul!(beta1).add!(grad, alpha: 1 - beta1)
+            exp_avg_sq.mul!(beta2).addcmul!(grad, grad, value: 1 - beta2)
             if amsgrad
               # Maintains the maximum of all 2nd moment running avg. till now
               Torch.max(max_exp_avg_sq, exp_avg_sq, out: max_exp_avg_sq)
@@ -71,7 +71,7 @@ module Torch
 
             step_size = group[:lr] / bias_correction1
 
-            p.data.addcdiv!(-step_size, exp_avg, denom)
+            p.data.addcdiv!(exp_avg, denom, value: -step_size)
           end
         end
 

data/lib/torch/optim/asgd.rb

@@ -36,14 +36,14 @@ module Torch
             state[:step] += 1
 
             if group[:weight_decay] != 0
-              grad = grad.add(group[:weight_decay], p.data)
+              grad = grad.add(p.data, alpha: group[:weight_decay])
             end
 
             # decay term
             p.data.mul!(1 - group[:lambd] * state[:eta])
 
             # update parameter
-            p.data.add!(-state[:eta], grad)
+            p.data.add!(grad, alpha: -state[:eta])
 
             # averaging
             if state[:mu] != 1

data/lib/torch/optim/rmsprop.rb

@@ -46,25 +46,25 @@ module Torch
             state[:step] += 1
 
             if group[:weight_decay] != 0
-              grad = grad.add(group[:weight_decay], p.data)
+              grad = grad.add(p.data, alpha: group[:weight_decay])
             end
 
-            square_avg.mul!(alpha).addcmul!(1 - alpha, grad, grad)
+            square_avg.mul!(alpha).addcmul!(grad, grad, value: 1 - alpha)
 
             if group[:centered]
               grad_avg = state[:grad_avg]
-              grad_avg.mul!(alpha).add!(1 - alpha, grad)
-              avg = square_avg.addcmul(-1, grad_avg, grad_avg).sqrt!.add!(group[:eps])
+              grad_avg.mul!(alpha).add!(grad, alpha: 1 - alpha)
+              avg = square_avg.addcmul(grad_avg, grad_avg, value: -1).sqrt!.add!(group[:eps])
             else
               avg = square_avg.sqrt.add!(group[:eps])
             end
 
             if group[:momentum] > 0
               buf = state[:momentum_buffer]
-              buf.mul!(group[:momentum]).addcdiv!(grad, avg)
-              p.data.add!(-group[:lr], buf)
+              buf.mul!(group[:momentum]).addcdiv!(grad, avg, value: 1)
+              p.data.add!(buf, alpha: -group[:lr])
             else
-              p.data.addcdiv!(-group[:lr], grad, avg)
+              p.data.addcdiv!(grad, avg, value: -group[:lr])
             end
           end
         end

data/lib/torch/optim/rprop.rb

@@ -52,7 +52,7 @@ module Torch
             grad[sign.eq(etaminus)] = 0
 
             # update parameters
-            p.data.addcmul!(-1, grad.sign, step_size)
+            p.data.addcmul!(grad.sign, step_size, value: -1)
 
             state[:prev].copy!(grad)
           end

data/lib/torch/optim/sgd.rb

@@ -32,24 +32,24 @@ module Torch
             next unless p.grad
             d_p = p.grad.data
             if weight_decay != 0
-              d_p.add!(weight_decay, p.data)
+              d_p.add!(p.data, alpha: weight_decay)
             end
             if momentum != 0
               param_state = @state[p]
-              if !param_state.key(:momentum_buffer)
+              if !param_state.key?(:momentum_buffer)
                 buf = param_state[:momentum_buffer] = Torch.clone(d_p).detach
               else
                 buf = param_state[:momentum_buffer]
-                buf.mul!(momentum).add!(1 - dampening, d_p)
+                buf.mul!(momentum).add!(d_p, alpha: 1 - dampening)
               end
               if nesterov
-                d_p = d_p.add(momentum, buf)
+                d_p = d_p.add(buf, alpha: momentum)
               else
                 d_p = buf
               end
             end
 
-            p.data.add!(-group[:lr], d_p)
+            p.data.add!(d_p, alpha: -group[:lr])
           end
         end
 

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,18 @@ 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
+      return _random!(0, *args) if args.size == 1
+      _random!(*args)
     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
+    # center option
+    def stft(*args)
+      Torch.stft(*args)
     end
   end
 end

data/lib/torch/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.5.1
 platform: ruby
 authors:
 - Andrew Kane
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-23 00:00:00.000000000 Z
+date: 2020-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -108,7 +108,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.1.1
-description: 
+description:
 email: andrew@chartkick.com
 executables: []
 extensions:
@@ -118,19 +118,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
@@ -270,7 +274,7 @@ homepage: https://github.com/ankane/torch.rb
 licenses:
 - BSD-3-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -285,8 +289,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Deep learning for Ruby, powered by LibTorch
 test_files: []

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