torch-rb 0.3.6 → 0.5.0

data/lib/torch/nn/init.rb

@@ -14,25 +14,11 @@ module Torch
           _normal!(tensor, mean, std)
         end
 
-        def constant!(tensor, val)
-          _constant!(tensor, val)
-        end
-
-        def ones!(tensor)
-          _ones!(tensor)
-        end
-
-        def zeros!(tensor)
-          _zeros!(tensor)
-        end
-
-        def eye!(tensor)
-          _eye!(tensor)
-        end
-
-        def dirac!(tensor)
-          _dirac!(tensor)
-        end
+        alias_method :constant!, :_constant!
+        alias_method :ones!, :_ones!
+        alias_method :zeros!, :_zeros!
+        alias_method :eye!, :_eye!
+        alias_method :dirac!, :_dirac!
 
         def xavier_uniform!(tensor, gain: 1.0)
           _xavier_uniform!(tensor, gain)

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/optim/adadelta.rb

@@ -39,14 +39,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
 
-            square_avg.mul!(rho).addcmul!(1 - rho, grad, grad)
+            square_avg.mul!(rho).addcmul!(grad, grad, value: 1 - rho)
             std = square_avg.add(eps).sqrt!
             delta = acc_delta.add(eps).sqrt!.div!(std).mul!(grad)
-            p.data.add!(-group[:lr], delta)
-            acc_delta.mul!(rho).addcmul!(1 - rho, delta, delta)
+            p.data.add!(delta, alpha: -group[:lr])
+            acc_delta.mul!(rho).addcmul!(delta, delta, value: 1 - rho)
           end
         end
 

data/lib/torch/optim/adagrad.rb

@@ -49,7 +49,7 @@ module Torch
               if p.grad.data.sparse?
                 raise Error, "weight_decay option is not compatible with sparse gradients"
               end
-              grad = grad.add(group[:weight_decay], p.data)
+              grad = grad.add(p.data, alpha: group[:weight_decay])
             end
 
             clr = group[:lr] / (1 + (state[:step] - 1) * group[:lr_decay])
@@ -57,9 +57,9 @@ module Torch
             if grad.sparse?
               raise NotImplementedYet
             else
-              state[:sum].addcmul!(1, grad, grad)
+              state[:sum].addcmul!(grad, grad, value: 1)
               std = state[:sum].sqrt.add!(group[:eps])
-              p.data.addcdiv!(-clr, grad, std)
+              p.data.addcdiv!(grad, std, value: -clr)
             end
           end
         end

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
@@ -48,6 +60,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)
 
@@ -68,14 +85,18 @@ module Torch
 
     def size(dim = nil)
       if dim
-        _size_int(dim)
+        _size(dim)
       else
         shape
       end
     end
 
-    def shape
-      dim.times.map { |i| size(i) }
+    def stride(dim = nil)
+      if dim
+        _stride(dim)
+      else
+        _strides
+      end
     end
 
     # mirror Python len()
@@ -119,60 +140,14 @@ module Torch
     end
 
     def type(dtype)
-      enum = DTYPE_TO_ENUM[dtype]
-      raise Error, "Unknown type: #{dtype}" unless enum
-      _type(enum)
-    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)
+      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
 
     # TODO better compare?
@@ -183,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
@@ -191,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