torch-rb 0.3.4 → 0.4.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,15 +1,44 @@
+#pragma once
+
 #include <torch/torch.h>
 #include <rice/Object.hpp>
-#include "templates.hpp"
 
-Object wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
+inline Object wrap(bool x) {
+  return to_ruby<bool>(x);
+}
+
+inline Object wrap(int64_t x) {
+  return to_ruby<int64_t>(x);
+}
+
+inline Object wrap(double x) {
+  return to_ruby<double>(x);
+}
+
+inline Object wrap(torch::Tensor x) {
+  return to_ruby<torch::Tensor>(x);
+}
+
+inline Object wrap(torch::Scalar x) {
+  return to_ruby<torch::Scalar>(x);
+}
+
+inline Object wrap(torch::ScalarType x) {
+  return to_ruby<torch::ScalarType>(x);
+}
+
+inline Object wrap(torch::QScheme x) {
+  return to_ruby<torch::QScheme>(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)));
@@ -17,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)));
@@ -26,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)));
@@ -36,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)));
@@ -45,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)));
@@ -53,3 +82,11 @@ Object wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
   a.push(to_ruby<int64_t>(std::get<3>(x)));
   return Object(a);
 }
+
+inline Object wrap(torch::TensorList x) {
+  Array a;
+  for (auto& t : x) {
+    a.push(to_ruby<torch::Tensor>(t));
+  }
+  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"
@@ -174,6 +169,9 @@ require "torch/nn/smooth_l1_loss"
 require "torch/nn/soft_margin_loss"
 require "torch/nn/triplet_margin_loss"
 
+# nn vision
+require "torch/nn/upsample"
+
 # nn other
 require "torch/nn/functional"
 require "torch/nn/init"
@@ -196,6 +194,32 @@ module Torch
     end
   end
 
+  # legacy
+  # but may make it easier to port tutorials
+  module Autograd
+    class Variable
+      def self.new(x)
+        raise ArgumentError, "Variable data has to be a tensor, but got #{x.class.name}" unless x.is_a?(Tensor)
+        warn "[torch] The Variable API is deprecated. Use tensors with requires_grad: true instead."
+        x
+      end
+    end
+  end
+
+  # TODO move to C++
+  class ByteStorage
+    # private
+    attr_reader :bytes
+
+    def initialize(bytes)
+      @bytes = bytes
+    end
+
+    def self.from_buffer(bytes)
+      new(bytes)
+    end
+  end
+
   # keys: https://pytorch.org/docs/stable/tensor_attributes.html#torch.torch.dtype
   # values: https://github.com/pytorch/pytorch/blob/master/c10/core/ScalarType.h
   DTYPE_TO_ENUM = {
@@ -224,40 +248,43 @@ module Torch
   }
   ENUM_TO_DTYPE = DTYPE_TO_ENUM.map(&:reverse).to_h
 
+  TENSOR_TYPE_CLASSES = []
+
   def self._make_tensor_class(dtype, cuda = false)
     cls = Class.new
     device = cuda ? "cuda" : "cpu"
     cls.define_singleton_method("new") do |*args|
       if args.size == 1 && args.first.is_a?(Tensor)
         args.first.send(dtype).to(device)
+      elsif args.size == 1 && args.first.is_a?(ByteStorage) && dtype == :uint8
+        bytes = args.first.bytes
+        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)
       else
         Torch.empty(*args, dtype: dtype, device: device)
       end
     end
+    TENSOR_TYPE_CLASSES << cls
     cls
   end
 
-  FloatTensor = _make_tensor_class(:float32)
-  DoubleTensor = _make_tensor_class(:float64)
-  HalfTensor = _make_tensor_class(:float16)
-  ByteTensor = _make_tensor_class(:uint8)
-  CharTensor = _make_tensor_class(:int8)
-  ShortTensor = _make_tensor_class(:int16)
-  IntTensor = _make_tensor_class(:int32)
-  LongTensor = _make_tensor_class(:int64)
-  BoolTensor = _make_tensor_class(:bool)
-
-  CUDA::FloatTensor = _make_tensor_class(:float32, true)
-  CUDA::DoubleTensor = _make_tensor_class(:float64, true)
-  CUDA::HalfTensor = _make_tensor_class(:float16, true)
-  CUDA::ByteTensor = _make_tensor_class(:uint8, true)
-  CUDA::CharTensor = _make_tensor_class(:int8, true)
-  CUDA::ShortTensor = _make_tensor_class(:int16, true)
-  CUDA::IntTensor = _make_tensor_class(:int32, true)
-  CUDA::LongTensor = _make_tensor_class(:int64, true)
-  CUDA::BoolTensor = _make_tensor_class(:bool, true)
+  DTYPE_TO_CLASS = {
+    float32: "FloatTensor",
+    float64: "DoubleTensor",
+    float16: "HalfTensor",
+    uint8: "ByteTensor",
+    int8: "CharTensor",
+    int16: "ShortTensor",
+    int32: "IntTensor",
+    int64: "LongTensor",
+    bool: "BoolTensor"
+  }
+
+  DTYPE_TO_CLASS.each do |dtype, class_name|
+    const_set(class_name, _make_tensor_class(dtype))
+    CUDA.const_set(class_name, _make_tensor_class(dtype, true))
+  end
 
   class << self
     # Torch.float, Torch.long, etc
@@ -342,59 +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)
-      _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

@@ -178,8 +178,12 @@ module Torch
           Torch.hardshrink(input, lambd)
         end
 
-        def leaky_relu(input, negative_slope = 0.01)
-          NN.leaky_relu(input, negative_slope)
+        def leaky_relu(input, negative_slope = 0.01, inplace: false)
+          if inplace
+            NN.leaky_relu!(input, negative_slope)
+          else
+            NN.leaky_relu(input, negative_slope)
+          end
         end
 
         def log_sigmoid(input)
@@ -390,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")
@@ -407,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)
@@ -442,31 +446,116 @@ 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
+
+        def interpolate(input, size: nil, scale_factor: nil, mode: "nearest", align_corners: nil, recompute_scale_factor: nil)
+          if ["nearest", "area"].include?(mode)
+            unless align_corners.nil?
+              raise ArgumentError, "align_corners option can only be set with the interpolating modes: linear | bilinear | bicubic | trilinear"
+            end
+          else
+            if align_corners.nil?
+              align_corners = false
+            end
+          end
+
+          scale_factor_len = input.dim - 2
+          scale_factor_list = [nil] * scale_factor_len
+          # default value of recompute_scale_factor is False
+          if !scale_factor.nil? && (recompute_scale_factor == false || recompute_scale_factor.nil?)
+            if scale_factor.is_a?(Array)
+              _scale_factor_repeated = scale_factor
+            else
+              _scale_factor_repeated = [scale_factor] * scale_factor_len
+            end
+            scale_factor_list = _scale_factor_repeated
+          end
+
+          # Give this variable a short name because it has to be repeated multiple times below.
+          sfl = scale_factor_list
+
+          closed_over_args = [input, size, scale_factor, recompute_scale_factor]
+          output_size = _interp_output_size(closed_over_args)
+          if input.dim == 3 && mode == "nearest"
+            NN.upsample_nearest1d(input, output_size, sfl[0])
+          elsif input.dim == 4 && mode == "nearest"
+            NN.upsample_nearest2d(input, output_size, sfl[0], sfl[1])
+          elsif input.dim == 5 && mode == "nearest"
+            NN.upsample_nearest3d(input, output_size, sfl[0], sfl[1], sfl[2])
+          elsif input.dim == 3 && mode == "area"
+            adaptive_avg_pool1d(input, output_size)
+          elsif input.dim == 4 && mode == "area"
+            adaptive_avg_pool2d(input, output_size)
+          elsif input.dim == 5 && mode == "area"
+            adaptive_avg_pool3d(input, output_size)
+          elsif input.dim == 3 && mode == "linear"
+            # assert align_corners is not None
+            NN.upsample_linear1d(input, output_size, align_corners, sfl[0])
+          elsif input.dim == 3 && mode == "bilinear"
+            raise ArgumentError, "Got 3D input, but bilinear mode needs 4D input"
+          elsif input.dim == 3 && mode == "trilinear"
+            raise ArgumentError, "Got 3D input, but trilinear mode needs 5D input"
+          elsif input.dim == 4 && mode == "linear"
+            raise ArgumentError, "Got 4D input, but linear mode needs 3D input"
+          elsif input.dim == 4 && mode == "bilinear"
+            # assert align_corners is not None
+            NN.upsample_bilinear2d(input, output_size, align_corners, sfl[0], sfl[1])
+          elsif input.dim == 4 && mode == "trilinear"
+            raise ArgumentError, "Got 4D input, but trilinear mode needs 5D input"
+          elsif input.dim == 5 && mode == "linear"
+            raise ArgumentError, "Got 5D input, but linear mode needs 3D input"
+          elsif input.dim == 5 && mode == "bilinear"
+            raise ArgumentError, "Got 5D input, but bilinear mode needs 4D input"
+          elsif input.dim == 5 && mode == "trilinear"
+            # assert align_corners is not None
+            NN.upsample_trilinear3d(input, output_size, align_corners, sfl[0], sfl[1], sfl[2])
+          elsif input.dim == 4 && mode == "bicubic"
+            # assert align_corners is not None
+            NN.upsample_bicubic2d(input, output_size, align_corners, sfl[0], sfl[1])
+          else
+            raise ArgumentError, "Input Error: Only 3D, 4D and 5D input Tensors supported (got #{input.dim}D) for the modes: nearest | linear | bilinear | bicubic | trilinear (got #{mode})"
+          end
         end
 
         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
@@ -480,6 +569,41 @@ module Torch
             out_size.zip(defaults.last(out_size.length)).map { |v, d| v || d }
           end
         end
+
+        def _interp_output_size(closed_over_args)
+          input, size, scale_factor, recompute_scale_factor = closed_over_args
+          dim = input.dim - 2
+          if size.nil? && scale_factor.nil?
+            raise ArgumentError, "either size or scale_factor should be defined"
+          end
+          if !size.nil? && !scale_factor.nil?
+            raise ArgumentError, "only one of size or scale_factor should be defined"
+          end
+          if !scale_factor.nil?
+            if scale_factor.is_a?(Array)
+              if scale_factor.length != dim
+                raise ArgumentError, "scale_factor shape must match input shape. Input is #{dim}D, scale_factor size is #{scale_factor.length}"
+              end
+            end
+          end
+
+          if !size.nil?
+            if size.is_a?(Array)
+              return size
+            else
+              return [size] * dim
+            end
+          end
+
+          raise "Failed assertion" if scale_factor.nil?
+          if scale_factor.is_a?(Array)
+            scale_factors = scale_factor
+          else
+            scale_factors = [scale_factor] * dim
+          end
+
+          dim.times.map { |i| (input.size(i + 2) * scale_factors[i]).floor }
+        end
       end
     end