torch-rb 0.3.7 → 0.4.0

data/ext/torch/tensor_functions.h

@@ -0,0 +1,6 @@
+// generated by rake generate:functions
+// do not edit by hand
+
+#pragma once
+
+void add_tensor_functions(Module m);

data/ext/torch/torch_functions.h

@@ -0,0 +1,6 @@
+// generated by rake generate:functions
+// do not edit by hand
+
+#pragma once
+
+void add_torch_functions(Module m);

data/ext/torch/utils.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <rice/Symbol.hpp>
+
+// keep THP prefix for now to make it easier to compare code
+
+extern VALUE THPVariableClass;
+
+inline VALUE THPUtils_internSymbol(const std::string& str) {
+  return 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));
+}
+
+inline bool THPUtils_checkSymbol(VALUE obj) {
+  return SYMBOL_P(obj);
+}
+
+inline bool THPUtils_checkIndex(VALUE obj) {
+  return FIXNUM_P(obj);
+}
+
+inline bool THPUtils_checkScalar(VALUE obj) {
+  return FIXNUM_P(obj) || RB_FLOAT_TYPE_P(obj) || RB_TYPE_P(obj, T_COMPLEX);
+}
+
+inline bool THPVariable_Check(VALUE obj) {
+  return rb_obj_is_kind_of(obj, THPVariableClass);
+}
+
+inline bool THPVariable_CheckExact(VALUE obj) {
+  return rb_obj_is_instance_of(obj, THPVariableClass);
+}

data/ext/torch/{templates.cpp → wrap_outputs.h}

@@ -1,43 +1,44 @@
+#pragma once
+
 #include <torch/torch.h>
 #include <rice/Object.hpp>
-#include "templates.hpp"
 
-Object wrap(bool x) {
+inline Object wrap(bool x) {
   return to_ruby<bool>(x);
 }
 
-Object wrap(int64_t x) {
+inline Object wrap(int64_t x) {
   return to_ruby<int64_t>(x);
 }
 
-Object wrap(double x) {
+inline Object wrap(double x) {
   return to_ruby<double>(x);
 }
 
-Object wrap(torch::Tensor x) {
+inline Object wrap(torch::Tensor x) {
   return to_ruby<torch::Tensor>(x);
 }
 
-Object wrap(torch::Scalar x) {
+inline Object wrap(torch::Scalar x) {
   return to_ruby<torch::Scalar>(x);
 }
 
-Object wrap(torch::ScalarType x) {
+inline Object wrap(torch::ScalarType x) {
   return to_ruby<torch::ScalarType>(x);
 }
 
-Object wrap(torch::QScheme x) {
+inline Object wrap(torch::QScheme x) {
   return to_ruby<torch::QScheme>(x);
 }
 
-Object wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
+inline Object wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
   Array a;
   a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
   a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
   return Object(a);
 }
 
-Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
+inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
   Array a;
   a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
   a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
@@ -45,7 +46,7 @@ Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
   return Object(a);
 }
 
-Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
+inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
   Array a;
   a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
   a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
@@ -54,7 +55,7 @@ Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tenso
   return Object(a);
 }
 
-Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
+inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
   Array a;
   a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
   a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
@@ -64,7 +65,7 @@ Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tenso
   return Object(a);
 }
 
-Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x) {
+inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x) {
   Array a;
   a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
   a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
@@ -73,7 +74,7 @@ Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x)
   return Object(a);
 }
 
-Object wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
+inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
   Array a;
   a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
   a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
@@ -82,7 +83,7 @@ Object wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
   return Object(a);
 }
 
-Object wrap(std::vector<torch::Tensor> x) {
+inline Object wrap(torch::TensorList x) {
   Array a;
   for (auto& t : x) {
     a.push(to_ruby<torch::Tensor>(t));

data/lib/torch.rb

@@ -7,11 +7,6 @@ require "net/http"
 require "set"
 require "tmpdir"
 
-# native functions
-require "torch/native/generator"
-require "torch/native/parser"
-require "torch/native/dispatcher"
-
 # modules
 require "torch/inspector"
 require "torch/tensor"
@@ -374,63 +369,6 @@ module Torch
 
     # --- begin tensor creation: https://pytorch.org/cppdocs/notes/tensor_creation.html ---
 
-    def arange(start, finish = nil, step = 1, **options)
-      # ruby doesn't support start = 0, finish, step = 1, ...
-      if finish.nil?
-        finish = start
-        start = 0
-      end
-      _arange(start, finish, step, tensor_options(**options))
-    end
-
-    def empty(*size, **options)
-      _empty(tensor_size(size), tensor_options(**options))
-    end
-
-    def eye(n, m = nil, **options)
-      _eye(n, m || n, tensor_options(**options))
-    end
-
-    def full(size, fill_value, **options)
-      _full(size, fill_value, tensor_options(**options))
-    end
-
-    def linspace(start, finish, steps = 100, **options)
-      _linspace(start, finish, steps, tensor_options(**options))
-    end
-
-    def logspace(start, finish, steps = 100, base = 10.0, **options)
-      _logspace(start, finish, steps, base, tensor_options(**options))
-    end
-
-    def ones(*size, **options)
-      _ones(tensor_size(size), tensor_options(**options))
-    end
-
-    def rand(*size, **options)
-      _rand(tensor_size(size), tensor_options(**options))
-    end
-
-    def randint(low = 0, high, size, **options)
-      _randint(low, high, size, tensor_options(**options))
-    end
-
-     def randn(*size, **options)
-      _randn(tensor_size(size), tensor_options(**options))
-    end
-
-    def randperm(n, **options)
-      # dtype hack in Python
-      # https://github.com/pytorch/pytorch/blob/v1.6.0/tools/autograd/gen_python_functions.py#L1307-L1311
-      options[:dtype] ||= :int64
-
-      _randperm(n, tensor_options(**options))
-    end
-
-    def zeros(*size, **options)
-      _zeros(tensor_size(size), tensor_options(**options))
-    end
-
     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

data/lib/torch/nn/functional.rb

@@ -394,15 +394,15 @@ module Torch
         # loss functions
 
         def binary_cross_entropy(input, target, weight: nil, reduction: "mean")
-          NN.binary_cross_entropy(input, target, weight, reduction)
+          NN.binary_cross_entropy(input, target, weight, to_reduction(reduction))
         end
 
         def binary_cross_entropy_with_logits(input, target, weight: nil, reduction: "mean", pos_weight: nil)
-          Torch.binary_cross_entropy_with_logits(input, target, weight, pos_weight, reduction)
+          Torch.binary_cross_entropy_with_logits(input, target, weight, pos_weight, to_reduction(reduction))
         end
 
         def cosine_embedding_loss(input1, input2, target, margin: 0, reduction: "mean")
-          Torch.cosine_embedding_loss(input1, input2, target, margin, reduction)
+          Torch.cosine_embedding_loss(input1, input2, target, margin, to_reduction(reduction))
         end
 
         def cross_entropy(input, target, weight: nil, ignore_index: -100, reduction: "mean")
@@ -411,34 +411,34 @@ module Torch
 
         def ctc_loss(log_probs, targets, input_lengths, target_lengths, blank: 0, reduction: "mean", zero_infinity: false)
           # call to_a on input_lengths and target_lengths for C++
-          Torch.ctc_loss(log_probs, targets, input_lengths.to_a, target_lengths.to_a, blank, reduction, zero_infinity)
+          Torch.ctc_loss(log_probs, targets, input_lengths.to_a, target_lengths.to_a, blank, to_reduction(reduction), zero_infinity)
         end
 
         def hinge_embedding_loss(input, target, margin: 1.0, reduction: "mean")
-          Torch.hinge_embedding_loss(input, target, margin, reduction)
+          Torch.hinge_embedding_loss(input, target, margin, to_reduction(reduction))
         end
 
         def kl_div(input, target, reduction: "mean")
-          Torch.kl_div(input, target, reduction)
+          Torch.kl_div(input, target, to_reduction(reduction))
         end
 
         def l1_loss(input, target, reduction: "mean")
-          NN.l1_loss(input, target, reduction)
+          NN.l1_loss(input, target, to_reduction(reduction))
         end
 
         def margin_ranking_loss(input1, input2, target, margin: 0, reduction: "mean")
-          Torch.margin_ranking_loss(input1, input2, target, margin, reduction)
+          Torch.margin_ranking_loss(input1, input2, target, margin, to_reduction(reduction))
         end
 
         def mse_loss(input, target, reduction: "mean")
           if target.size != input.size
             warn "Using a target size (#{target.size}) that is different to the input size (#{input.size}). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size."
           end
-          NN.mse_loss(input, target, reduction)
+          NN.mse_loss(input, target, to_reduction(reduction))
         end
 
         def multilabel_margin_loss(input, target, reduction: "mean")
-          NN.multilabel_margin_loss(input, target, reduction)
+          NN.multilabel_margin_loss(input, target, to_reduction(reduction))
         end
 
         def multilabel_soft_margin_loss(input, target, weight: nil)
@@ -446,27 +446,27 @@ module Torch
         end
 
         def multi_margin_loss(input, target, p: 1, margin: 1.0, weight: nil, reduction: "mean")
-          NN.multi_margin_loss(input, target, p, margin, weight, reduction)
+          NN.multi_margin_loss(input, target, p, margin, weight, to_reduction(reduction))
         end
 
         def nll_loss(input, target, weight: nil, ignore_index: -100, reduction: "mean")
-          NN.nll_loss(input, target, weight, reduction, ignore_index)
+          NN.nll_loss(input, target, weight, to_reduction(reduction), ignore_index)
         end
 
         def poisson_nll_loss(input, target, log_input: true, full: false, eps: 1e-8, reduction: "mean")
-          Torch.poisson_nll_loss(input, target, log_input, full, eps, reduction)
+          Torch.poisson_nll_loss(input, target, log_input, full, eps, to_reduction(reduction))
         end
 
         def soft_margin_loss(input, target, reduction: "mean")
-          NN.soft_margin_loss(input, target, reduction)
+          NN.soft_margin_loss(input, target, to_reduction(reduction))
         end
 
         def smooth_l1_loss(input, target, reduction: "mean")
-          NN.smooth_l1_loss(input, target, reduction)
+          NN.smooth_l1_loss(input, target, to_reduction(reduction))
         end
 
         def triplet_margin_loss(anchor, positive, negative, margin: 1.0, p: 2, eps: 1e-06, swap: false, reduction: "mean")
-          Torch.triplet_margin_loss(anchor, positive, negative, margin, p, eps, swap, reduction)
+          Torch.triplet_margin_loss(anchor, positive, negative, margin, p, eps, swap, to_reduction(reduction))
         end
 
         # vision
@@ -542,6 +542,20 @@ module Torch
 
         private
 
+        # see _reduction.py
+        def to_reduction(v)
+          case v.to_s
+          when "none"
+            0
+          when "mean"
+            1
+          when "sum"
+            2
+          else
+            raise ArgumentError, "#{v} is not a valid value for reduction"
+          end
+        end
+
         def softmax_dim(ndim)
           ndim == 0 || ndim == 1 || ndim == 3 ? 0 : 1
         end

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

@@ -45,7 +45,7 @@ module Torch
             square_avg.mul!(rho).addcmul!(1 - rho, grad, grad)
             std = square_avg.add(eps).sqrt!
             delta = acc_delta.add(eps).sqrt!.div!(std).mul!(grad)
-            p.data.add!(-group[:lr], delta)
+            p.data.add!(delta, alpha: -group[:lr])
             acc_delta.mul!(rho).addcmul!(1 - rho, delta, delta)
           end
         end

data/lib/torch/optim/adam.rb

@@ -53,11 +53,11 @@ 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.mul!(beta1).add!(grad, alpha: 1 - beta1)
             exp_avg_sq.mul!(beta2).addcmul!(1 - beta2, grad, grad)
             if amsgrad
               # Maintains the maximum of all 2nd moment running avg. till now

data/lib/torch/optim/adamax.rb

@@ -46,7 +46,7 @@ module Torch
             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),

data/lib/torch/optim/adamw.rb

@@ -58,7 +58,7 @@ 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.mul!(beta1).add!(grad, alpha: 1 - beta1)
             exp_avg_sq.mul!(beta2).addcmul!(1 - beta2, grad, grad)
             if amsgrad
               # Maintains the maximum of all 2nd moment running avg. till now

data/lib/torch/optim/asgd.rb

@@ -43,7 +43,7 @@ module Torch
             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/sgd.rb

@@ -32,7 +32,7 @@ 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]
@@ -40,7 +40,7 @@ module Torch
                 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)
@@ -49,7 +49,7 @@ module Torch
               end
             end
 
-            p.data.add!(-group[:lr], d_p)
+            p.data.add!(d_p, alpha: -group[:lr])
           end
         end