torch-rb 0.3.7 → 0.5.1

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,10 +83,17 @@ 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));
   }
   return Object(a);
 }
+
+inline Object wrap(std::tuple<double, double> x) {
+  Array a;
+  a.push(to_ruby<double>(std::get<0>(x)));
+  a.push(to_ruby<double>(std::get<1>(x)));
+  return Object(a);
+}

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"
@@ -266,6 +261,8 @@ module Torch
         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)
+      elsif args.size == 0
+        Torch.empty(0, dtype: dtype, device: device)
       else
         Torch.empty(*args, dtype: dtype, device: device)
       end
@@ -374,63 +371,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
@@ -496,7 +436,8 @@ module Torch
       zeros(input.size, **like_options(input, options))
     end
 
-    def stft(input, n_fft, hop_length: nil, win_length: nil, window: nil, center: true, pad_mode: "reflect", normalized: false, onesided: true)
+    # center option
+    def stft(input, n_fft, hop_length: nil, win_length: nil, window: nil, center: true, pad_mode: "reflect", normalized: false, onesided: true, return_complex: nil)
       if center
         signal_dim = input.dim
         extended_shape = [1] * (3 - signal_dim) + input.size
@@ -504,12 +445,7 @@ module Torch
         input = NN::F.pad(input.view(extended_shape), [pad, pad], mode: pad_mode)
         input = input.view(input.shape[-signal_dim..-1])
       end
-      _stft(input, n_fft, hop_length, win_length, window, normalized, onesided)
-    end
-
-    def clamp(tensor, min, max)
-      tensor = _clamp_min(tensor, min)
-      _clamp_max(tensor, max)
+      _stft(input, n_fft, hop_length, win_length, window, normalized, onesided, return_complex)
     end
 
     private

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

@@ -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