torch-rb 0.2.7 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3451d6140ae6a6a9294a73571239df703a9dc753911c5d97a83bcb020b9d878d
-  data.tar.gz: 65689090d9fe4d9dee078b2f0f0f56526d76158306390c0988e61b0e2ca98ff1
+  metadata.gz: fa01dc7cfd168494f1066f4e692eb08dee7f419126b2d10a6eb5b2b22fe01526
+  data.tar.gz: 9e69a7da9ecc85c51bd9cfb42b93f1b1aa6148958ed8bc16ffb0555b6d42159d
 SHA512:
-  metadata.gz: 9f2cc800b8c0e7a3a75bbb9c4705e7e306ed68f52a90530d22659a4d23d8ce0126c1cfd9bc7c33612a842bc20199ba8ec7f488bbba591073d8914f108948e084
-  data.tar.gz: dbf34592bef6e869a3814f20e891d2d566339080a46d335a5e42f114477a5769f63ee18ca3ee8b8f1d031faf898dfe4f6861064f0cb0773b6d75622b4a663e0f
+  metadata.gz: 36bc620212235e57a40d9e791b3eae85fbd73c7224a5445e2e94e49c7a3ec4cb638024193d8e47817e577a72ef96976fdf2851f3607fd3ea1712255bca0e1ec1
+  data.tar.gz: 888971d06717b610020644ed720ae48fa645a90790d54692ac64a565434b550ce4f778688f0a22806f018656dd9d6183d6510fc458c8c5e82c0629951489279c

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 0.3.4 (2020-08-26)
+
+- Added `Torch.clamp` method
+
+## 0.3.3 (2020-08-25)
+
+- Added spectral ops
+- Fixed tensor indexing
+
+## 0.3.2 (2020-08-24)
+
+- Added `enable_grad` method
+- Added `random_split` method
+- Added `collate_fn` option to `DataLoader`
+- Added `grad=` method to `Tensor`
+- Fixed error with `grad` method when empty
+- Fixed `EmbeddingBag`
+
+## 0.3.1 (2020-08-17)
+
+- Added `create_graph` and `retain_graph` options to `backward` method
+- Fixed error when `set` not required
+
+## 0.3.0 (2020-07-29)
+
+- Updated LibTorch to 1.6.0
+- Removed `state_dict` method from optimizers until `load_state_dict` is implemented
+
 ## 0.2.7 (2020-06-29)
 
 - Made tensors enumerable
@@ -43,7 +71,7 @@
 ## 0.2.0 (2020-04-22)
 
 - No longer experimental
-- Updated libtorch to 1.5.0
+- Updated LibTorch to 1.5.0
 - Added support for GPUs and OpenMP
 - Added adaptive pooling layers
 - Tensor `dtype` is now based on Numo type for `Torch.tensor`
@@ -52,7 +80,7 @@
 
 ## 0.1.8 (2020-01-17)
 
-- Updated libtorch to 1.4.0
+- Updated LibTorch to 1.4.0
 
 ## 0.1.7 (2020-01-10)
 

data/README.md

@@ -2,7 +2,11 @@
 
 :fire: Deep learning for Ruby, powered by [LibTorch](https://pytorch.org)
 
-For computer vision tasks, also check out [TorchVision](https://github.com/ankane/torchvision)
+Check out:
+
+- [TorchVision](https://github.com/ankane/torchvision) for computer vision tasks
+- [TorchText](https://github.com/ankane/torchtext) for text and NLP tasks
+- [TorchAudio](https://github.com/ankane/torchaudio) for audio tasks
 
 [![Build Status](https://travis-ci.org/ankane/torch.rb.svg?branch=master)](https://travis-ci.org/ankane/torch.rb)
 
@@ -42,6 +46,8 @@ This library follows the [PyTorch API](https://pytorch.org/docs/stable/torch.htm
 - Methods that return booleans use `?` instead of `is_`  (`tensor?` instead of `is_tensor`)
 - Numo is used instead of NumPy (`x.numo` instead of `x.numpy()`)
 
+You can follow PyTorch tutorials and convert the code to Ruby in many cases. Feel free to open an issue if you run into problems.
+
 ## Tutorial
 
 Some examples below are from [Deep Learning with PyTorch: A 60 Minutes Blitz](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)
@@ -409,7 +415,8 @@ Here’s the list of compatible versions.
 
 Torch.rb | LibTorch
 --- | ---
-0.2.0+ | 1.5.0+
+0.3.0-0.3.4 | 1.6.0
+0.2.0-0.2.7 | 1.5.0-1.5.1
 0.1.8 | 1.4.0
 0.1.0-0.1.7 | 1.3.1
 

data/ext/torch/ext.cpp

@@ -16,6 +16,7 @@
 #include "nn_functions.hpp"
 
 using namespace Rice;
+using torch::indexing::TensorIndex;
 
 // need to make a distinction between parameters and tensors
 class Parameter: public torch::autograd::Variable {
@@ -28,6 +29,15 @@ void handle_error(torch::Error const & ex)
   throw Exception(rb_eRuntimeError, ex.what_without_backtrace());
 }
 
+std::vector<TensorIndex> index_vector(Array a) {
+  auto indices = std::vector<TensorIndex>();
+  indices.reserve(a.size());
+  for (size_t i = 0; i < a.size(); i++) {
+    indices.push_back(from_ruby<TensorIndex>(a[i]));
+  }
+  return indices;
+}
+
 extern "C"
 void Init_ext()
 {
@@ -48,15 +58,23 @@ void Init_ext()
     .define_singleton_method(
       "initial_seed",
       *[]() {
-        return at::detail::getDefaultCPUGenerator()->current_seed();
+        return at::detail::getDefaultCPUGenerator().current_seed();
       })
     .define_singleton_method(
       "seed",
       *[]() {
         // TODO set for CUDA when available
-        return at::detail::getDefaultCPUGenerator()->seed();
+        auto generator = at::detail::getDefaultCPUGenerator();
+        return generator.seed();
       });
 
+  Class rb_cTensorIndex = define_class_under<TensorIndex>(rb_mTorch, "TensorIndex")
+    .define_singleton_method("boolean", *[](bool value) { return TensorIndex(value); })
+    .define_singleton_method("integer", *[](int64_t value) { return TensorIndex(value); })
+    .define_singleton_method("tensor", *[](torch::Tensor& value) { return TensorIndex(value); })
+    .define_singleton_method("slice", *[](torch::optional<int64_t> start_index, torch::optional<int64_t> stop_index) { return TensorIndex(torch::indexing::Slice(start_index, stop_index)); })
+    .define_singleton_method("none", *[]() { return TensorIndex(torch::indexing::None); });
+
   // https://pytorch.org/cppdocs/api/structc10_1_1_i_value.html
   Class rb_cIValue = define_class_under<torch::IValue>(rb_mTorch, "IValue")
     .add_handler<torch::Error>(handle_error)
@@ -329,6 +347,18 @@ void Init_ext()
     .define_method("numel", &torch::Tensor::numel)
     .define_method("element_size", &torch::Tensor::element_size)
     .define_method("requires_grad", &torch::Tensor::requires_grad)
+    .define_method(
+      "_index",
+      *[](Tensor& self, Array indices) {
+        auto vec = index_vector(indices);
+        return self.index(vec);
+      })
+    .define_method(
+      "_index_put_custom",
+      *[](Tensor& self, Array indices, torch::Tensor& value) {
+        auto vec = index_vector(indices);
+        return self.index_put_(vec, value);
+      })
     .define_method(
       "contiguous?",
       *[](Tensor& self) {
@@ -351,13 +381,19 @@ void Init_ext()
       })
     .define_method(
       "_backward",
-      *[](Tensor& self, Object gradient) {
-        return gradient.is_nil() ? self.backward() : self.backward(from_ruby<torch::Tensor>(gradient));
+      *[](Tensor& self, OptionalTensor gradient, bool create_graph, bool retain_graph) {
+        return self.backward(gradient, create_graph, retain_graph);
       })
     .define_method(
       "grad",
       *[](Tensor& self) {
-        return self.grad();
+        auto grad = self.grad();
+        return grad.defined() ? to_ruby<torch::Tensor>(grad) : Nil;
+      })
+    .define_method(
+      "grad=",
+      *[](Tensor& self, torch::Tensor& grad) {
+        self.grad() = grad;
       })
     .define_method(
       "_dtype",
@@ -460,7 +496,7 @@ void Init_ext()
     .define_singleton_method(
       "_make_subclass",
       *[](Tensor& rd, bool requires_grad) {
-        auto data = torch::autograd::as_variable_ref(rd).detach();
+        auto data = rd.detach();
         data.unsafeGetTensorImpl()->set_allow_tensor_metadata_change(true);
         auto var = data.set_requires_grad(requires_grad);
         return Parameter(std::move(var));
@@ -501,6 +537,7 @@ void Init_ext()
       });
 
   Module rb_mInit = define_module_under(rb_mNN, "Init")
+    .add_handler<torch::Error>(handle_error)
     .define_singleton_method(
       "_calculate_gain",
       *[](NonlinearityType nonlinearity, double param) {
@@ -579,11 +616,16 @@ void Init_ext()
       *[](Parameter& self) {
         auto grad = self.grad();
         return grad.defined() ? to_ruby<torch::Tensor>(grad) : Nil;
+      })
+    .define_method(
+      "grad=",
+      *[](Parameter& self, torch::Tensor& grad) {
+        self.grad() = grad;
       });
 
   Class rb_cDevice = define_class_under<torch::Device>(rb_mTorch, "Device")
-    .define_constructor(Constructor<torch::Device, std::string>())
     .add_handler<torch::Error>(handle_error)
+    .define_constructor(Constructor<torch::Device, std::string>())
     .define_method("index", &torch::Device::index)
     .define_method("index?", &torch::Device::has_index)
     .define_method(

data/ext/torch/extconf.rb

@@ -7,17 +7,16 @@ $CXXFLAGS += " -std=c++14"
 # change to 0 for Linux pre-cxx11 ABI version
 $CXXFLAGS += " -D_GLIBCXX_USE_CXX11_ABI=1"
 
-# TODO check compiler name
-clang = RbConfig::CONFIG["host_os"] =~ /darwin/i
+apple_clang = RbConfig::CONFIG["CC_VERSION_MESSAGE"] =~ /apple clang/i
 
 # check omp first
 if have_library("omp") || have_library("gomp")
   $CXXFLAGS += " -DAT_PARALLEL_OPENMP=1"
-  $CXXFLAGS += " -Xclang" if clang
+  $CXXFLAGS += " -Xclang" if apple_clang
   $CXXFLAGS += " -fopenmp"
 end
 
-if clang
+if apple_clang
   # silence ruby/intern.h warning
   $CXXFLAGS += " -Wno-deprecated-register"
 

data/ext/torch/templates.hpp

@@ -9,6 +9,10 @@
 
 using namespace Rice;
 
+using torch::Device;
+using torch::ScalarType;
+using torch::Tensor;
+
 // need to wrap torch::IntArrayRef() since
 // it doesn't own underlying data
 class IntArrayRef {
@@ -174,8 +178,6 @@ MyReduction from_ruby<MyReduction>(Object x)
   return MyReduction(x);
 }
 
-typedef torch::Tensor Tensor;
-
 class OptionalTensor {
   Object value;
   public:
@@ -197,47 +199,28 @@ OptionalTensor from_ruby<OptionalTensor>(Object x)
   return OptionalTensor(x);
 }
 
-class ScalarType {
-  Object value;
-  public:
-    ScalarType(Object o) {
-      value = o;
-    }
-    operator at::ScalarType() {
-      throw std::runtime_error("ScalarType arguments not implemented yet");
-    }
-};
-
 template<>
 inline
-ScalarType from_ruby<ScalarType>(Object x)
+torch::optional<torch::ScalarType> from_ruby<torch::optional<torch::ScalarType>>(Object x)
 {
-  return ScalarType(x);
+  if (x.is_nil()) {
+    return torch::nullopt;
+  } else {
+    return torch::optional<torch::ScalarType>{from_ruby<torch::ScalarType>(x)};
+  }
 }
 
-class OptionalScalarType {
-  Object value;
-  public:
-    OptionalScalarType(Object o) {
-      value = o;
-    }
-    operator c10::optional<at::ScalarType>() {
-      if (value.is_nil()) {
-        return c10::nullopt;
-      }
-      return ScalarType(value);
-    }
-};
-
 template<>
 inline
-OptionalScalarType from_ruby<OptionalScalarType>(Object x)
+torch::optional<int64_t> from_ruby<torch::optional<int64_t>>(Object x)
 {
-  return OptionalScalarType(x);
+  if (x.is_nil()) {
+    return torch::nullopt;
+  } else {
+    return torch::optional<int64_t>{from_ruby<int64_t>(x)};
+  }
 }
 
-typedef torch::Device Device;
-
 Object wrap(std::tuple<torch::Tensor, torch::Tensor> x);
 Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x);
 Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x);

data/lib/torch.rb

@@ -4,6 +4,7 @@ require "torch/ext"
 # stdlib
 require "fileutils"
 require "net/http"
+require "set"
 require "tmpdir"
 
 # native functions
@@ -178,8 +179,10 @@ require "torch/nn/functional"
 require "torch/nn/init"
 
 # utils
+require "torch/utils/data"
 require "torch/utils/data/data_loader"
 require "torch/utils/data/dataset"
+require "torch/utils/data/subset"
 require "torch/utils/data/tensor_dataset"
 
 # hub
@@ -315,6 +318,16 @@ module Torch
       end
     end
 
+    def enable_grad
+      previous_value = grad_enabled?
+      begin
+        _set_grad_enabled(true)
+        yield
+      ensure
+        _set_grad_enabled(previous_value)
+      end
+    end
+
     def device(str)
       Device.new(str)
     end
@@ -447,6 +460,22 @@ 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)
+      if center
+        signal_dim = input.dim
+        extended_shape = [1] * (3 - signal_dim) + input.size
+        pad = n_fft.div(2).to_i
+        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)
+    end
+
     private
 
     def to_ivalue(obj)
@@ -470,11 +499,7 @@ module Torch
       when nil
         IValue.new
       when Array
-        if obj.all? { |v| v.is_a?(Tensor) }
-          IValue.from_list(obj.map { |v| IValue.from_tensor(v) })
-        else
-          raise Error, "Unknown list type"
-        end
+        IValue.from_list(obj.map { |v| to_ivalue(v) })
       else
         raise Error, "Unknown type: #{obj.class.name}"
       end

data/lib/torch/hub.rb

@@ -7,25 +7,26 @@ module Torch
 
       def download_url_to_file(url, dst)
         uri = URI(url)
-        tmp = "#{Dir.tmpdir}/#{Time.now.to_f}" # TODO better name
+        tmp = nil
         location = nil
 
+        puts "Downloading #{url}..."
         Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
           request = Net::HTTP::Get.new(uri)
 
-          puts "Downloading #{url}..."
-          File.open(tmp, "wb") do |f|
-            http.request(request) do |response|
-              case response
-              when Net::HTTPRedirection
-                location = response["location"]
-              when Net::HTTPSuccess
+          http.request(request) do |response|
+            case response
+            when Net::HTTPRedirection
+              location = response["location"]
+            when Net::HTTPSuccess
+              tmp = "#{Dir.tmpdir}/#{Time.now.to_f}" # TODO better name
+              File.open(tmp, "wb") do |f|
                 response.read_body do |chunk|
                   f.write(chunk)
                 end
-              else
-                raise Error, "Bad response"
               end
+            else
+              raise Error, "Bad response"
             end
           end
         end

data/lib/torch/native/function.rb

@@ -1,10 +1,14 @@
 module Torch
   module Native
     class Function
-      attr_reader :function
+      attr_reader :function, :tensor_options
 
       def initialize(function)
         @function = function
+
+        tensor_options_str = ", *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None)"
+        @tensor_options = @function["func"].include?(tensor_options_str)
+        @function["func"].sub!(tensor_options_str, ")")
       end
 
       def func

data/lib/torch/native/generator.rb

@@ -33,30 +33,14 @@ module Torch
               f.args.any? do |a|
                 a[:type].include?("?") && !["Tensor?", "Generator?", "int?", "ScalarType?", "Tensor?[]"].include?(a[:type]) ||
                 skip_args.any? { |sa| a[:type].include?(sa) } ||
+                # call to 'range' is ambiguous
+                f.cpp_name == "_range" ||
                 # native_functions.yaml is missing size argument for normal
                 # https://pytorch.org/cppdocs/api/function_namespacetorch_1a80253fe5a3ded4716ec929a348adb4b9.html
                 (f.base_name == "normal" && !f.out?)
               end
             end
 
-          # generate additional functions for optional arguments
-          # there may be a better way to do this
-          optional_functions, functions = functions.partition { |f| f.args.any? { |a| a[:type] == "int?" } }
-          optional_functions.each do |f|
-            next if f.ruby_name == "cross"
-            next if f.ruby_name.start_with?("avg_pool") && f.out?
-
-            opt_args = f.args.select { |a| a[:type] == "int?" }
-            if opt_args.size == 1
-              sep = f.name.include?(".") ? "_" : "."
-              f1 = Function.new(f.function.merge("func" => f.func.sub("(", "#{sep}#{opt_args.first[:name]}(").gsub("int?", "int")))
-              # TODO only remove some arguments
-              f2 = Function.new(f.function.merge("func" => f.func.sub(/, int\?.+\) ->/, ") ->")))
-              functions << f1
-              functions << f2
-            end
-          end
-
           # todo_functions.each do |f|
           #   puts f.func
           #   puts
@@ -97,7 +81,8 @@ void add_%{type}_functions(Module m) {
 
           cpp_defs = []
           functions.sort_by(&:cpp_name).each do |func|
-            fargs = func.args #.select { |a| a[:type] != "Generator?" }
+            fargs = func.args.dup #.select { |a| a[:type] != "Generator?" }
+            fargs << {name: "options", type: "TensorOptions"} if func.tensor_options
 
             cpp_args = []
             fargs.each do |a|
@@ -109,7 +94,7 @@ void add_%{type}_functions(Module m) {
                   # TODO better signature
                   "OptionalTensor"
                 when "ScalarType?"
-                  "OptionalScalarType"
+                  "torch::optional<ScalarType>"
                 when "Tensor[]"
                   "TensorList"
                 when "Tensor?[]"
@@ -117,6 +102,8 @@ void add_%{type}_functions(Module m) {
                   "TensorList"
                 when "int"
                   "int64_t"
+                when "int?"
+                  "torch::optional<int64_t>"
                 when "float"
                   "double"
                 when /\Aint\[/
@@ -125,6 +112,8 @@ void add_%{type}_functions(Module m) {
                   "Tensor &"
                 when "str"
                   "std::string"
+                when "TensorOptions"
+                  "const torch::TensorOptions &"
                 else
                   a[:type]
                 end