torch-rb 0.2.1 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b37dc4dd7be5806879c2fb5bb52ac94c8b16eba76bc2a3c591ca4cbe51cf8745
-  data.tar.gz: 6415d14f7cc8baa4db9205c709b70fec2b90b4dff1b60de97c299c2a7edfbf40
+  metadata.gz: da5c88539a2890933e44859af7c1acfe835405c89e82bc6a6fb2df37fdee141a
+  data.tar.gz: 747ab48ba1b0ba16077ed31cf505f622a4120d18be9c0942ded39810095aa68e
 SHA512:
-  metadata.gz: cf43cb21e18171f76f1291f2cccdb8a93141605fe33d4421eaf799a4589638d33da040b2ffad3ddce34fec60ab2b41edf1fa9a247d69de7f31e157063e57f331
-  data.tar.gz: 3c858de8e7eb6169359fad18104c08d9a4011a305f44c4a8213a289b005dc4439b1959a40effd8b1bba1c2e96a871b28f01695fdda56e6ad0aeed0c2334cfa25
+  metadata.gz: d2bccf16e7af54d53affbc12030fd89f417fd060afa7057e97765bca00c24b7089f74b9e8aa4bab9180045e466649676f481425dc24ab29533b74138bb03e786
+  data.tar.gz: 8eb49a743fedb220df4edc39d7d0c492c1827ce63f2c5d9a8d73495da63da5f6055674ca0bd60bb0b81be68db6e5c9300357de2c417e82e7af4fafd1ab6c7ca2

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## 0.2.6 (2020-06-29)
+
+- Added support for indexing with tensors
+- Added `contiguous` methods
+- Fixed named parameters for nested parameters
+
+## 0.2.5 (2020-06-07)
+
+- Added `download_url_to_file` and `load_state_dict_from_url` to `Torch::Hub`
+- Improved error messages
+- Fixed tensor slicing
+
+## 0.2.4 (2020-04-29)
+
+- Added `to_i` and `to_f` to tensors
+- Added `shuffle` option to data loader
+- Fixed `modules` and `named_modules` for nested modules
+
+## 0.2.3 (2020-04-28)
+
+- Added `show_config` and `parallel_info` methods
+- Added `initial_seed` and `seed` methods to `Random`
+- Improved data loader
+- Build with MKL-DNN and NNPACK when available
+- Fixed `inspect` for modules
+
+## 0.2.2 (2020-04-27)
+
+- Added support for saving tensor lists
+- Added `ndim` and `ndimension` methods to tensors
+
 ## 0.2.1 (2020-04-26)
 
 - Added support for saving and loading models

data/README.md

@@ -2,6 +2,8 @@
 
 :fire: Deep learning for Ruby, powered by [LibTorch](https://pytorch.org)
 
+For computer vision tasks, also check out [TorchVision](https://github.com/ankane/torchvision)
+
 [![Build Status](https://travis-ci.org/ankane/torch.rb.svg?branch=master)](https://travis-ci.org/ankane/torch.rb)
 
 ## Installation
@@ -22,6 +24,18 @@ It can take a few minutes to compile the extension.
 
 ## Getting Started
 
+Deep learning is significantly faster with a GPU. If you don’t have an NVIDIA GPU, we recommend using a cloud service. [Paperspace](https://www.paperspace.com/) has a great free plan.
+
+We’ve put together a [Docker image](https://github.com/ankane/ml-stack) to make it easy to get started. On Paperspace, create a notebook with a custom container. Set the container name to:
+
+```text
+ankane/ml-stack:torch-gpu
+```
+
+And leave the other fields in that section blank. Once the notebook is running, you can run the [MNIST example](https://github.com/ankane/ml-stack/blob/master/torch-gpu/MNIST.ipynb).
+
+## API
+
 This library follows the [PyTorch API](https://pytorch.org/docs/stable/torch.html). There are a few changes to make it more Ruby-like:
 
 - Methods that perform in-place modifications end with `!` instead of `_` (`add!` instead of `add_`)
@@ -192,7 +206,7 @@ end
 Define a neural network
 
 ```ruby
-class Net < Torch::NN::Module
+class MyNet < Torch::NN::Module
   def initialize
     super
     @conv1 = Torch::NN::Conv2d.new(1, 6, 3)
@@ -226,7 +240,7 @@ end
 Create an instance of it
 
 ```ruby
-net = Net.new
+net = MyNet.new
 input = Torch.randn(1, 1, 32, 32)
 net.call(input)
 ```
@@ -294,7 +308,7 @@ Torch.save(net.state_dict, "net.pth")
 Load a model
 
 ```ruby
-net = Net.new
+net = MyNet.new
 net.load_state_dict(Torch.load("net.pth"))
 net.eval
 ```
@@ -395,7 +409,7 @@ Here’s the list of compatible versions.
 
 Torch.rb | LibTorch
 --- | ---
-0.2.0 | 1.5.0
+0.2.0+ | 1.5.0+
 0.1.8 | 1.4.0
 0.1.0-0.1.7 | 1.3.1
 
@@ -413,9 +427,7 @@ Then install the gem (no need for `bundle config`).
 
 ### Linux
 
-Deep learning is significantly faster on GPUs.
-
-Install [CUDA](https://developer.nvidia.com/cuda-downloads) and [cuDNN](https://developer.nvidia.com/cudnn) and reinstall the gem.
+Deep learning is significantly faster on a GPU. Install [CUDA](https://developer.nvidia.com/cuda-downloads) and [cuDNN](https://developer.nvidia.com/cudnn) and reinstall the gem.
 
 Check if CUDA is available
 
@@ -426,7 +438,7 @@ Torch::CUDA.available?
 Move a neural network to a GPU
 
 ```ruby
-net.to("cuda")
+net.cuda
 ```
 
 ## rbenv

data/ext/torch/ext.cpp

@@ -23,7 +23,7 @@ class Parameter: public torch::autograd::Variable {
     Parameter(Tensor&& t) : torch::autograd::Variable(t) { }
 };
 
-void handle_error(c10::Error const & ex)
+void handle_error(torch::Error const & ex)
 {
   throw Exception(rb_eRuntimeError, ex.what_without_backtrace());
 }
@@ -32,16 +32,34 @@ extern "C"
 void Init_ext()
 {
   Module rb_mTorch = define_module("Torch");
+  rb_mTorch.add_handler<torch::Error>(handle_error);
   add_torch_functions(rb_mTorch);
 
   Class rb_cTensor = define_class_under<torch::Tensor>(rb_mTorch, "Tensor");
+  rb_cTensor.add_handler<torch::Error>(handle_error);
   add_tensor_functions(rb_cTensor);
 
   Module rb_mNN = define_module_under(rb_mTorch, "NN");
+  rb_mNN.add_handler<torch::Error>(handle_error);
   add_nn_functions(rb_mNN);
 
+  Module rb_mRandom = define_module_under(rb_mTorch, "Random")
+    .add_handler<torch::Error>(handle_error)
+    .define_singleton_method(
+      "initial_seed",
+      *[]() {
+        return at::detail::getDefaultCPUGenerator()->current_seed();
+      })
+    .define_singleton_method(
+      "seed",
+      *[]() {
+        // TODO set for CUDA when available
+        return at::detail::getDefaultCPUGenerator()->seed();
+      });
+
   // 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)
     .define_constructor(Constructor<torch::IValue>())
     .define_method("bool?", &torch::IValue::isBool)
     .define_method("bool_list?", &torch::IValue::isBoolList)
@@ -82,6 +100,16 @@ void Init_ext()
       *[](torch::IValue& self) {
         return self.toInt();
       })
+    .define_method(
+      "to_list",
+      *[](torch::IValue& self) {
+        auto list = self.toListRef();
+        Array obj;
+        for (auto& elem : list) {
+          obj.push(to_ruby<torch::IValue>(torch::IValue{elem}));
+        }
+        return obj;
+      })
     .define_method(
       "to_string_ref",
       *[](torch::IValue& self) {
@@ -96,17 +124,27 @@ void Init_ext()
       "to_generic_dict",
       *[](torch::IValue& self) {
         auto dict = self.toGenericDict();
-        Hash h;
+        Hash obj;
         for (auto& pair : dict) {
-          h[to_ruby<torch::IValue>(torch::IValue{pair.key()})] = to_ruby<torch::IValue>(torch::IValue{pair.value()});
+          obj[to_ruby<torch::IValue>(torch::IValue{pair.key()})] = to_ruby<torch::IValue>(torch::IValue{pair.value()});
         }
-        return h;
+        return obj;
       })
     .define_singleton_method(
       "from_tensor",
       *[](torch::Tensor& v) {
         return torch::IValue(v);
       })
+    // TODO create specialized list types?
+    .define_singleton_method(
+      "from_list",
+      *[](Array obj) {
+        c10::impl::GenericList list(c10::AnyType::get());
+        for (auto entry : obj) {
+          list.push_back(from_ruby<torch::IValue>(entry));
+        }
+        return torch::IValue(list);
+      })
     .define_singleton_method(
       "from_string",
       *[](String v) {
@@ -157,6 +195,17 @@ void Init_ext()
       *[](uint64_t seed) {
         return torch::manual_seed(seed);
       })
+    // config
+    .define_singleton_method(
+      "show_config",
+      *[] {
+        return torch::show_config();
+      })
+    .define_singleton_method(
+      "parallel_info",
+      *[] {
+        return torch::get_parallel_info();
+      })
     // begin tensor creation
     .define_singleton_method(
       "_arange",
@@ -273,7 +322,6 @@ void Init_ext()
       });
 
   rb_cTensor
-    .add_handler<c10::Error>(handle_error)
     .define_method("cuda?", &torch::Tensor::is_cuda)
     .define_method("sparse?", &torch::Tensor::is_sparse)
     .define_method("quantized?", &torch::Tensor::is_quantized)
@@ -281,6 +329,11 @@ 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(
+      "contiguous?",
+      *[](Tensor& self) {
+        return self.is_contiguous();
+      })
     .define_method(
       "addcmul!",
       *[](Tensor& self, Scalar value, const Tensor & tensor1, const Tensor & tensor2) {
@@ -330,6 +383,21 @@ void Init_ext()
         s << self.device();
         return s.str();
       })
+    .define_method(
+      "_data_str",
+      *[](Tensor& self) {
+        Tensor tensor = self;
+
+        // move to CPU to get data
+        if (tensor.device().type() != torch::kCPU) {
+          torch::Device device("cpu");
+          tensor = tensor.to(device);
+        }
+
+        auto data_ptr = (const char *) tensor.data_ptr();
+        return std::string(data_ptr, tensor.numel() * tensor.element_size());
+      })
+    // TODO figure out a better way to do this
     .define_method(
       "_flat_data",
       *[](Tensor& self) {
@@ -344,46 +412,40 @@ void Init_ext()
         Array a;
         auto dtype = tensor.dtype();
 
+        Tensor view = tensor.reshape({tensor.numel()});
+
         // TODO DRY if someone knows C++
         if (dtype == torch::kByte) {
-          uint8_t* data = tensor.data_ptr<uint8_t>();
           for (int i = 0; i < tensor.numel(); i++) {
-            a.push(data[i]);
+            a.push(view[i].item().to<uint8_t>());
           }
         } else if (dtype == torch::kChar) {
-          int8_t* data = tensor.data_ptr<int8_t>();
           for (int i = 0; i < tensor.numel(); i++) {
-            a.push(to_ruby<int>(data[i]));
+            a.push(to_ruby<int>(view[i].item().to<int8_t>()));
           }
         } else if (dtype == torch::kShort) {
-          int16_t* data = tensor.data_ptr<int16_t>();
           for (int i = 0; i < tensor.numel(); i++) {
-            a.push(data[i]);
+            a.push(view[i].item().to<int16_t>());
           }
         } else if (dtype == torch::kInt) {
-          int32_t* data = tensor.data_ptr<int32_t>();
           for (int i = 0; i < tensor.numel(); i++) {
-            a.push(data[i]);
+            a.push(view[i].item().to<int32_t>());
           }
         } else if (dtype == torch::kLong) {
-          int64_t* data = tensor.data_ptr<int64_t>();
           for (int i = 0; i < tensor.numel(); i++) {
-            a.push(data[i]);
+            a.push(view[i].item().to<int64_t>());
           }
         } else if (dtype == torch::kFloat) {
-          float* data = tensor.data_ptr<float>();
           for (int i = 0; i < tensor.numel(); i++) {
-            a.push(data[i]);
+            a.push(view[i].item().to<float>());
           }
         } else if (dtype == torch::kDouble) {
-          double* data = tensor.data_ptr<double>();
           for (int i = 0; i < tensor.numel(); i++) {
-            a.push(data[i]);
+            a.push(view[i].item().to<double>());
           }
         } else if (dtype == torch::kBool) {
-          bool* data = tensor.data_ptr<bool>();
           for (int i = 0; i < tensor.numel(); i++) {
-            a.push(data[i] ? True : False);
+            a.push(view[i].item().to<bool>() ? True : False);
           }
         } else {
           throw std::runtime_error("Unsupported type");
@@ -405,7 +467,7 @@ void Init_ext()
       });
 
   Class rb_cTensorOptions = define_class_under<torch::TensorOptions>(rb_mTorch, "TensorOptions")
-    .add_handler<c10::Error>(handle_error)
+    .add_handler<torch::Error>(handle_error)
     .define_constructor(Constructor<torch::TensorOptions>())
     .define_method(
       "dtype",
@@ -511,6 +573,7 @@ void Init_ext()
       });
 
   Class rb_cParameter = define_class_under<Parameter, torch::Tensor>(rb_mNN, "Parameter")
+    .add_handler<torch::Error>(handle_error)
     .define_method(
       "grad",
       *[](Parameter& self) {
@@ -520,6 +583,7 @@ void Init_ext()
 
   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_method("index", &torch::Device::index)
     .define_method("index?", &torch::Device::has_index)
     .define_method(
@@ -531,6 +595,7 @@ void Init_ext()
       });
 
   Module rb_mCUDA = define_module_under(rb_mTorch, "CUDA")
+    .add_handler<torch::Error>(handle_error)
     .define_singleton_method("available?", &torch::cuda::is_available)
     .define_singleton_method("device_count", &torch::cuda::device_count);
 }

data/ext/torch/extconf.rb

@@ -2,33 +2,33 @@ require "mkmf-rice"
 
 abort "Missing stdc++" unless have_library("stdc++")
 
-$CXXFLAGS << " -std=c++14"
+$CXXFLAGS += " -std=c++14"
 
 # change to 0 for Linux pre-cxx11 ABI version
-$CXXFLAGS << " -D_GLIBCXX_USE_CXX11_ABI=1"
+$CXXFLAGS += " -D_GLIBCXX_USE_CXX11_ABI=1"
 
 # TODO check compiler name
 clang = RbConfig::CONFIG["host_os"] =~ /darwin/i
 
 # check omp first
 if have_library("omp") || have_library("gomp")
-  $CXXFLAGS << " -DAT_PARALLEL_OPENMP=1"
-  $CXXFLAGS << " -Xclang" if clang
-  $CXXFLAGS << " -fopenmp"
+  $CXXFLAGS += " -DAT_PARALLEL_OPENMP=1"
+  $CXXFLAGS += " -Xclang" if clang
+  $CXXFLAGS += " -fopenmp"
 end
 
 if clang
   # silence ruby/intern.h warning
-  $CXXFLAGS << " -Wno-deprecated-register"
+  $CXXFLAGS += " -Wno-deprecated-register"
 
   # silence torch warnings
-  $CXXFLAGS << " -Wno-shorten-64-to-32 -Wno-missing-noreturn"
+  $CXXFLAGS += " -Wno-shorten-64-to-32 -Wno-missing-noreturn"
 else
   # silence rice warnings
-  $CXXFLAGS << " -Wno-noexcept-type"
+  $CXXFLAGS += " -Wno-noexcept-type"
 
   # silence torch warnings
-  $CXXFLAGS << " -Wno-duplicated-cond -Wno-suggest-attribute=noreturn"
+  $CXXFLAGS += " -Wno-duplicated-cond -Wno-suggest-attribute=noreturn"
 end
 
 inc, lib = dir_config("torch")
@@ -39,27 +39,30 @@ cuda_inc, cuda_lib = dir_config("cuda")
 cuda_inc ||= "/usr/local/cuda/include"
 cuda_lib ||= "/usr/local/cuda/lib64"
 
-$LDFLAGS << " -L#{lib}" if Dir.exist?(lib)
+$LDFLAGS += " -L#{lib}" if Dir.exist?(lib)
 abort "LibTorch not found" unless have_library("torch")
 
+have_library("mkldnn")
+have_library("nnpack")
+
 with_cuda = false
 if Dir["#{lib}/*torch_cuda*"].any?
-  $LDFLAGS << " -L#{cuda_lib}" if Dir.exist?(cuda_lib)
+  $LDFLAGS += " -L#{cuda_lib}" if Dir.exist?(cuda_lib)
   with_cuda = have_library("cuda") && have_library("cudnn")
 end
 
-$INCFLAGS << " -I#{inc}"
-$INCFLAGS << " -I#{inc}/torch/csrc/api/include"
+$INCFLAGS += " -I#{inc}"
+$INCFLAGS += " -I#{inc}/torch/csrc/api/include"
 
-$LDFLAGS << " -Wl,-rpath,#{lib}"
-$LDFLAGS << ":#{cuda_lib}/stubs:#{cuda_lib}" if with_cuda
+$LDFLAGS += " -Wl,-rpath,#{lib}"
+$LDFLAGS += ":#{cuda_lib}/stubs:#{cuda_lib}" if with_cuda
 
 # https://github.com/pytorch/pytorch/blob/v1.5.0/torch/utils/cpp_extension.py#L1232-L1238
-$LDFLAGS << " -lc10 -ltorch_cpu -ltorch"
+$LDFLAGS += " -lc10 -ltorch_cpu -ltorch"
 if with_cuda
-  $LDFLAGS << " -lcuda -lnvrtc -lnvToolsExt -lcudart -lc10_cuda -ltorch_cuda -lcufft -lcurand -lcublas -lcudnn"
+  $LDFLAGS += " -lcuda -lnvrtc -lnvToolsExt -lcudart -lc10_cuda -ltorch_cuda -lcufft -lcurand -lcublas -lcudnn"
   # TODO figure out why this is needed
-  $LDFLAGS << " -Wl,--no-as-needed,#{lib}/libtorch.so"
+  $LDFLAGS += " -Wl,--no-as-needed,#{lib}/libtorch.so"
 end
 
 # generate C++ functions

data/lib/torch.rb

@@ -1,6 +1,11 @@
 # ext
 require "torch/ext"
 
+# stdlib
+require "fileutils"
+require "net/http"
+require "tmpdir"
+
 # native functions
 require "torch/native/generator"
 require "torch/native/parser"
@@ -174,11 +179,9 @@ require "torch/nn/init"
 
 # utils
 require "torch/utils/data/data_loader"
+require "torch/utils/data/dataset"
 require "torch/utils/data/tensor_dataset"
 
-# random
-require "torch/random"
-
 # hub
 require "torch/hub"
 
@@ -466,6 +469,12 @@ module Torch
         IValue.from_bool(obj)
       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
       else
         raise Error, "Unknown type: #{obj.class.name}"
       end
@@ -490,6 +499,8 @@ module Torch
           dict[to_ruby(k)] = to_ruby(v)
         end
         dict
+      elsif ivalue.list?
+        ivalue.to_list.map { |v| to_ruby(v) }
       else
         type =
           if ivalue.capsule?
@@ -510,8 +521,6 @@ module Torch
             "BoolList"
           elsif ivalue.tensor_list?
             "TensorList"
-          elsif ivalue.list?
-            "List"
           elsif ivalue.object?
             "Object"
           elsif ivalue.module?

data/lib/torch/hub.rb

@@ -4,6 +4,58 @@ module Torch
       def list(github, force_reload: false)
         raise NotImplementedYet
       end
+
+      def download_url_to_file(url, dst)
+        uri = URI(url)
+        tmp = "#{Dir.tmpdir}/#{Time.now.to_f}" # TODO better name
+        location = nil
+
+        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
+                response.read_body do |chunk|
+                  f.write(chunk)
+                end
+              else
+                raise Error, "Bad response"
+              end
+            end
+          end
+        end
+
+        if location
+          download_url_to_file(location, dst)
+        else
+          FileUtils.mv(tmp, dst)
+          nil
+        end
+      end
+
+      def load_state_dict_from_url(url, model_dir: nil)
+        unless model_dir
+          torch_home = ENV["TORCH_HOME"] || "#{ENV["XDG_CACHE_HOME"] || "#{ENV["HOME"]}/.cache"}/torch"
+          model_dir = File.join(torch_home, "checkpoints")
+        end
+
+        FileUtils.mkdir_p(model_dir)
+
+        parts = URI(url)
+        filename = File.basename(parts.path)
+        cached_file = File.join(model_dir, filename)
+        unless File.exist?(cached_file)
+          # TODO support hash_prefix
+          download_url_to_file(url, cached_file)
+        end
+
+        Torch.load(cached_file)
+      end
     end
   end
 end

data/lib/torch/inspector.rb

@@ -1,6 +1,6 @@
 module Torch
   module Inspector
-    # TODO make more performance, especially when summarizing
+    # TODO make more performant, especially when summarizing
     # how? only read data that will be displayed
     def inspect
       data =
@@ -14,7 +14,7 @@ module Torch
           if dtype == :bool
             fmt = "%s"
           else
-            values = to_a.flatten
+            values = _flat_data
             abs = values.select { |v| v != 0 }.map(&:abs)
             max = abs.max || 1
             min = abs.min || 1
@@ -25,7 +25,7 @@ module Torch
             end
 
             if floating_point?
-              sci = max / min.to_f > 1000 || max > 1e8 || min < 1e-4
+              sci = max > 1e8 || max < 1e-4
 
               all_int = values.all? { |v| v.finite? && v == v.to_i }
               decimal = all_int ? 1 : 4

data/lib/torch/native/function.rb

@@ -66,6 +66,7 @@ module Torch
             end
 
             next if t == "Generator?"
+            next if t == "MemoryFormat"
             next if t == "MemoryFormat?"
             args << {name: k, type: t, default: d, pos: pos, has_default: has_default}
           end

data/lib/torch/native/generator.rb

@@ -18,7 +18,7 @@ module Torch
           functions = functions()
 
           # skip functions
-          skip_args = ["bool[3]", "Dimname", "MemoryFormat", "Layout", "Storage", "ConstQuantizerPtr"]
+          skip_args = ["bool[3]", "Dimname", "Layout", "Storage", "ConstQuantizerPtr"]
 
           # remove functions
           functions.reject! do |f|
@@ -31,7 +31,7 @@ module Torch
           todo_functions, functions =
             functions.partition do |f|
               f.args.any? do |a|
-                a[:type].include?("?") && !["Tensor?", "Generator?", "int?", "ScalarType?"].include?(a[:type]) ||
+                a[:type].include?("?") && !["Tensor?", "Generator?", "int?", "ScalarType?", "Tensor?[]"].include?(a[:type]) ||
                 skip_args.any? { |sa| a[:type].include?(sa) } ||
                 # native_functions.yaml is missing size argument for normal
                 # https://pytorch.org/cppdocs/api/function_namespacetorch_1a80253fe5a3ded4716ec929a348adb4b9.html
@@ -112,6 +112,9 @@ void add_%{type}_functions(Module m) {
                   "OptionalScalarType"
                 when "Tensor[]"
                   "TensorList"
+                when "Tensor?[]"
+                  # TODO make optional
+                  "TensorList"
                 when "int"
                   "int64_t"
                 when "float"

data/lib/torch/native/parser.rb

@@ -75,7 +75,7 @@ module Torch
                 v.is_a?(Tensor)
               when "Tensor?"
                 v.nil? || v.is_a?(Tensor)
-              when "Tensor[]"
+              when "Tensor[]", "Tensor?[]"
                 v.is_a?(Array) && v.all? { |v2| v2.is_a?(Tensor) }
               when "int"
                 if k == "reduction"

data/lib/torch/nn/batch_norm.rb

@@ -70,6 +70,11 @@ module Torch
           momentum: exponential_average_factor, eps: @eps
         )
       end
+
+      def extra_inspect
+        s = "%{num_features}, eps: %{eps}, momentum: %{momentum}, affine: %{affine}, track_running_stats: %{track_running_stats}"
+        format(s, **dict)
+      end
     end
   end
 end

data/lib/torch/nn/conv2d.rb

@@ -20,7 +20,14 @@ module Torch
 
       # TODO add more parameters
       def extra_inspect
-        format("%s, %s, kernel_size: %s, stride: %s", @in_channels, @out_channels, @kernel_size, @stride)
+        s = String.new("%{in_channels}, %{out_channels}, kernel_size: %{kernel_size}, stride: %{stride}")
+        s += ", padding: %{padding}" if @padding != [0] * @padding.size
+        s += ", dilation: %{dilation}" if @dilation != [1] * @dilation.size
+        s += ", output_padding: %{output_padding}" if @output_padding != [0] * @output_padding.size
+        s += ", groups: %{groups}" if @groups != 1
+        s += ", bias: false" unless @bias
+        s += ", padding_mode: %{padding_mode}" if @padding_mode != "zeros"
+        format(s, **dict)
       end
     end
   end

data/lib/torch/nn/convnd.rb

@@ -23,7 +23,7 @@ module Torch
         if bias
           @bias = Parameter.new(Tensor.new(out_channels))
         else
-          raise NotImplementedError
+          register_parameter("bias", nil)
         end
         reset_parameters
       end

data/lib/torch/nn/max_poolnd.rb

@@ -12,7 +12,8 @@ module Torch
       end
 
       def extra_inspect
-        format("kernel_size: %s", @kernel_size)
+        s = "kernel_size: %{kernel_size}, stride: %{stride}, padding: %{padding}, dilation: %{dilation}, ceil_mode: %{ceil_mode}"
+        format(s, **dict)
       end
     end
   end

data/lib/torch/nn/module.rb

@@ -145,7 +145,7 @@ module Torch
         params = {}
         if recurse
           named_children.each do |name, mod|
-            params.merge!(mod.named_parameters(prefix: "#{name}.", recurse: recurse))
+            params.merge!(mod.named_parameters(prefix: "#{prefix}#{name}.", recurse: recurse))
           end
         end
         instance_variables.each do |name|
@@ -186,8 +186,22 @@ module Torch
         named_modules.values
       end
 
-      def named_modules
-        {"" => self}.merge(named_children)
+      # TODO return enumerator?
+      def named_modules(memo: nil, prefix: "")
+        ret = {}
+        memo ||= Set.new
+        unless memo.include?(self)
+          memo << self
+          ret[prefix] = self
+          named_children.each do |name, mod|
+            next unless mod.is_a?(Module)
+            submodule_prefix = prefix + (!prefix.empty? ? "." : "") + name
+            mod.named_modules(memo: memo, prefix: submodule_prefix).each do |m|
+              ret[m[0]] = m[1]
+            end
+          end
+        end
+        ret
       end
 
       def train(mode = true)
@@ -224,13 +238,15 @@ module Torch
 
       def inspect
         name = self.class.name.split("::").last
-        if children.empty?
+        if named_children.empty?
           "#{name}(#{extra_inspect})"
         else
           str = String.new
           str << "#{name}(\n"
-          children.each do |name, mod|
-            str << "  (#{name}): #{mod.inspect}\n"
+          named_children.each do |name, mod|
+            mod_str = mod.inspect
+            mod_str = mod_str.lines.join("  ")
+            str << "  (#{name}): #{mod_str}\n"
           end
           str << ")"
         end

data/lib/torch/optim/rprop.rb

@@ -11,9 +11,6 @@ module Torch
       end
 
       def step(closure = nil)
-        # TODO implement []=
-        raise NotImplementedYet
-
         loss = nil
         if closure
           loss = closure.call

data/lib/torch/tensor.rb

@@ -4,6 +4,8 @@ module Torch
     include Inspector
 
     alias_method :requires_grad?, :requires_grad
+    alias_method :ndim, :dim
+    alias_method :ndimension, :dim
 
     def self.new(*args)
       FloatTensor.new(*args)
@@ -23,8 +25,17 @@ module Torch
       inspect
     end
 
+    # TODO make more performant
     def to_a
-      reshape_arr(_flat_data, shape)
+      arr = _flat_data
+      if shape.empty?
+        arr
+      else
+        shape[1..-1].reverse.each do |dim|
+          arr = arr.each_slice(dim)
+        end
+        arr.to_a
+      end
     end
 
     # TODO support dtype
@@ -62,7 +73,15 @@ module Torch
       if numel != 1
         raise Error, "only one element tensors can be converted to Ruby scalars"
       end
-      _flat_data.first
+      to_a.first
+    end
+
+    def to_i
+      item.to_i
+    end
+
+    def to_f
+      item.to_f
     end
 
     # unsure if this is correct
@@ -78,7 +97,7 @@ module Torch
     def numo
       cls = Torch._dtype_to_numo[dtype]
       raise Error, "Cannot convert #{dtype} to Numo" unless cls
-      cls.cast(_flat_data).reshape(*shape)
+      cls.from_string(_data_str).reshape(*shape)
     end
 
     def new_ones(*size, **options)
@@ -106,15 +125,6 @@ module Torch
       _view(size)
     end
 
-    # 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
-    end
-
     def +(other)
       add(other)
     end
@@ -143,11 +153,13 @@ module Torch
       neg
     end
 
+    # TODO better compare?
     def <=>(other)
       item <=> other
     end
 
-    # based on python_variable_indexing.cpp
+    # based on python_variable_indexing.cpp and
+    # https://pytorch.org/cppdocs/notes/tensor_indexing.html
     def [](*indexes)
       result = self
       dim = 0
@@ -159,6 +171,8 @@ module Torch
           finish += 1 unless index.exclude_end?
           result = result._slice_tensor(dim, index.begin, finish, 1)
           dim += 1
+        elsif index.is_a?(Tensor)
+          result = result.index([index])
         elsif index.nil?
           result = result.unsqueeze(dim)
           dim += 1
@@ -172,12 +186,12 @@ module Torch
       result
     end
 
-    # TODO
-    # based on python_variable_indexing.cpp
+    # based on python_variable_indexing.cpp and
+    # https://pytorch.org/cppdocs/notes/tensor_indexing.html
     def []=(index, value)
       raise ArgumentError, "Tensor does not support deleting items" if value.nil?
 
-      value = Torch.tensor(value) unless value.is_a?(Tensor)
+      value = Torch.tensor(value, dtype: dtype) unless value.is_a?(Tensor)
 
       if index.is_a?(Numeric)
         copy_to(_select_int(0, index), value)
@@ -185,13 +199,39 @@ module Torch
         finish = index.end
         finish += 1 unless index.exclude_end?
         copy_to(_slice_tensor(0, index.begin, finish, 1), value)
+      elsif index.is_a?(Tensor)
+        index_put!([index], value)
       else
         raise Error, "Unsupported index type: #{index.class.name}"
       end
     end
 
-    def random!(from = 0, to)
-      _random__from_to(from, to)
+    # 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
+    end
+
+    # native functions overlap, so need to handle manually
+    def random!(*args)
+      case args.size
+      when 1
+        _random__to(*args)
+      when 2
+        _random__from_to(*args)
+      else
+        _random_(*args)
+      end
+    end
+
+    def clamp!(min, max)
+      _clamp_min_(min)
+      _clamp_max_(max)
     end
 
     private
@@ -199,17 +239,5 @@ module Torch
     def copy_to(dst, src)
       dst.copy!(src)
     end
-
-    def reshape_arr(arr, dims)
-      if dims.empty?
-        arr
-      else
-        arr = arr.flatten
-        dims[1..-1].reverse.each do |dim|
-          arr = arr.each_slice(dim)
-        end
-        arr.to_a
-      end
-    end
   end
 end

data/lib/torch/utils/data/data_loader.rb

@@ -6,21 +6,49 @@ module Torch
 
         attr_reader :dataset
 
-        def initialize(dataset, batch_size: 1)
+        def initialize(dataset, batch_size: 1, shuffle: false)
           @dataset = dataset
           @batch_size = batch_size
+          @shuffle = shuffle
         end
 
         def each
-          size.times do |i|
-            start_index = i * @batch_size
-            yield @dataset[start_index...(start_index + @batch_size)]
+          # try to keep the random number generator in sync with Python
+          # this makes it easy to compare results
+          base_seed = Torch.empty([], dtype: :int64).random!.item
+
+          indexes =
+            if @shuffle
+              Torch.randperm(@dataset.size).to_a
+            else
+              @dataset.size.times
+            end
+
+          indexes.each_slice(@batch_size) do |idx|
+            batch = idx.map { |i| @dataset[i] }
+            yield collate(batch)
           end
         end
 
         def size
           (@dataset.size / @batch_size.to_f).ceil
         end
+
+        private
+
+        def collate(batch)
+          elem = batch[0]
+          case elem
+          when Tensor
+            Torch.stack(batch, 0)
+          when Integer
+            Torch.tensor(batch)
+          when Array
+            batch.transpose.map { |v| collate(v) }
+          else
+            raise NotImpelmentYet
+          end
+        end
       end
     end
   end

data/lib/torch/utils/data/dataset.rb

@@ -0,0 +1,8 @@
+module Torch
+  module Utils
+    module Data
+      class Dataset
+      end
+    end
+  end
+end

data/lib/torch/utils/data/tensor_dataset.rb

@@ -1,7 +1,7 @@
 module Torch
   module Utils
     module Data
-      class TensorDataset
+      class TensorDataset < Dataset
         def initialize(*tensors)
           unless tensors.all? { |t| t.size(0) == tensors[0].size(0) }
             raise Error, "Tensors must all have same dim 0 size"

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.2.1"
+  VERSION = "0.2.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.6
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-27 00:00:00.000000000 Z
+date: 2020-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -95,19 +95,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: npy
+  name: torchvision
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
 description: 
 email: andrew@chartkick.com
 executables: []
@@ -258,9 +258,9 @@ files:
 - lib/torch/optim/rmsprop.rb
 - lib/torch/optim/rprop.rb
 - lib/torch/optim/sgd.rb
-- lib/torch/random.rb
 - lib/torch/tensor.rb
 - lib/torch/utils/data/data_loader.rb
+- lib/torch/utils/data/dataset.rb
 - lib/torch/utils/data/tensor_dataset.rb
 - lib/torch/version.rb
 homepage: https://github.com/ankane/torch.rb

data/lib/torch/random.rb

@@ -1,10 +0,0 @@
-module Torch
-  module Random
-    class << self
-      # not available through LibTorch
-      def initial_seed
-        raise NotImplementedYet
-      end
-    end
-  end
-end