torch-rb 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9179470135a00453dcae9efbc6cd143112c5fec925bb5675a686e80e70b71b28
-  data.tar.gz: de365f50021d75338a78bcb6e0733bb430759fe7c4fcaea96b1ff0ed2a4b8d5d
+  metadata.gz: 8f6ab78fb5cff27d0d60ddb9c08fb2f526bd60e241dd1011554b21716bdd2f43
+  data.tar.gz: 5568f53d8d5d688e3f29fb55ddbe9457e0b933dc69f59b422035c0cee249e396
 SHA512:
-  metadata.gz: 46d3d49aa63c0764d20178f450aa0b88c88938c194e70040650e6c1a29899e5f4d896671571730dc23eb1fe039ede53d2714db0f6fe7506ad4382653a5e6ec18
-  data.tar.gz: 3fe47be264030fc2d84de85bb7d006337df37fb5c41b147332fe37dd21de7ba61bdc53a0f7ae9085e01c992a643b22d8216a0248b7a4d24487d88fd7f88a9ecf
+  metadata.gz: 9c5dcfbf35382b37678662690677b2b90d0d544e8802703cf83dba6e10483a4df487f9687e4e898c9cc449c568f4e02f9d831daa982b5b3135af6f9ce176ec88
+  data.tar.gz: 34f142d874606e140661ae992a9f8cd4779f95c93c11d9a89a1864dd0bd53c5480c30d9aec5897f1955e2450bd0a3bc56ed0868e3b54d82ff4cdba40af379840

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## 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
+- Improved error messages
+- Reduced gem size
+
 ## 0.2.0 (2020-04-22)
 
 - No longer experimental

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)
 ```
@@ -283,6 +297,22 @@ loss.backward
 optimizer.step
 ```
 
+### Saving and Loading Models
+
+Save a model
+
+```ruby
+Torch.save(net.state_dict, "net.pth")
+```
+
+Load a model
+
+```ruby
+net = MyNet.new
+net.load_state_dict(Torch.load("net.pth"))
+net.eval
+```
+
 ### Tensor Creation
 
 Here’s a list of functions to create tensors (descriptions from the [C++ docs](https://pytorch.org/cppdocs/notes/tensor_creation.html)):
@@ -397,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
 
@@ -410,7 +438,7 @@ Torch::CUDA.available?
 Move a neural network to a GPU
 
 ```ruby
-net.to("cuda")
+net.cuda
 ```
 
 ## rbenv
@@ -445,6 +473,8 @@ bundle exec rake compile -- --with-torch-dir=/path/to/libtorch
 bundle exec rake test
 ```
 
+You can use [this script](https://gist.github.com/ankane/9b2b5fcbd66d6e4ccfeb9d73e529abe7) to test on GPUs with the AWS Deep Learning Base AMI (Ubuntu 18.04).
+
 Here are some good resources for contributors:
 
 - [PyTorch API](https://pytorch.org/docs/stable/torch.html)

data/ext/torch/ext.cpp

@@ -5,6 +5,7 @@
 #include <rice/Array.hpp>
 #include <rice/Class.hpp>
 #include <rice/Constructor.hpp>
+#include <rice/Hash.hpp>
 
 #include "templates.hpp"
 
@@ -22,18 +23,163 @@ class Parameter: public torch::autograd::Variable {
     Parameter(Tensor&& t) : torch::autograd::Variable(t) { }
 };
 
+void handle_error(torch::Error const & ex)
+{
+  throw Exception(rb_eRuntimeError, ex.what_without_backtrace());
+}
+
 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)
+    .define_method("capsule?", &torch::IValue::isCapsule)
+    .define_method("custom_class?", &torch::IValue::isCustomClass)
+    .define_method("device?", &torch::IValue::isDevice)
+    .define_method("double?", &torch::IValue::isDouble)
+    .define_method("double_list?", &torch::IValue::isDoubleList)
+    .define_method("future?", &torch::IValue::isFuture)
+    // .define_method("generator?", &torch::IValue::isGenerator)
+    .define_method("generic_dict?", &torch::IValue::isGenericDict)
+    .define_method("list?", &torch::IValue::isList)
+    .define_method("int?", &torch::IValue::isInt)
+    .define_method("int_list?", &torch::IValue::isIntList)
+    .define_method("module?", &torch::IValue::isModule)
+    .define_method("none?", &torch::IValue::isNone)
+    .define_method("object?", &torch::IValue::isObject)
+    .define_method("ptr_type?", &torch::IValue::isPtrType)
+    .define_method("py_object?", &torch::IValue::isPyObject)
+    .define_method("r_ref?", &torch::IValue::isRRef)
+    .define_method("scalar?", &torch::IValue::isScalar)
+    .define_method("string?", &torch::IValue::isString)
+    .define_method("tensor?", &torch::IValue::isTensor)
+    .define_method("tensor_list?", &torch::IValue::isTensorList)
+    .define_method("tuple?", &torch::IValue::isTuple)
+    .define_method(
+      "to_bool",
+      *[](torch::IValue& self) {
+        return self.toBool();
+      })
+    .define_method(
+      "to_double",
+      *[](torch::IValue& self) {
+        return self.toDouble();
+      })
+    .define_method(
+      "to_int",
+      *[](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) {
+        return self.toStringRef();
+      })
+    .define_method(
+      "to_tensor",
+      *[](torch::IValue& self) {
+        return self.toTensor();
+      })
+    .define_method(
+      "to_generic_dict",
+      *[](torch::IValue& self) {
+        auto dict = self.toGenericDict();
+        Hash obj;
+        for (auto& pair : dict) {
+          obj[to_ruby<torch::IValue>(torch::IValue{pair.key()})] = to_ruby<torch::IValue>(torch::IValue{pair.value()});
+        }
+        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) {
+        return torch::IValue(v.str());
+      })
+    .define_singleton_method(
+      "from_int",
+      *[](int64_t v) {
+        return torch::IValue(v);
+      })
+    .define_singleton_method(
+      "from_double",
+      *[](double v) {
+        return torch::IValue(v);
+      })
+    .define_singleton_method(
+      "from_bool",
+      *[](bool v) {
+        return torch::IValue(v);
+      })
+    // see https://github.com/pytorch/pytorch/blob/master/torch/csrc/jit/python/pybind_utils.h
+    // createGenericDict and toIValue
+    .define_singleton_method(
+      "from_dict",
+      *[](Hash obj) {
+        auto key_type = c10::AnyType::get();
+        auto value_type = c10::AnyType::get();
+        c10::impl::GenericDict elems(key_type, value_type);
+        elems.reserve(obj.size());
+        for (auto entry : obj) {
+          elems.insert(from_ruby<torch::IValue>(entry.first), from_ruby<torch::IValue>((Object) entry.second));
+        }
+        return torch::IValue(std::move(elems));
+      });
+
   rb_mTorch.define_singleton_method(
       "grad_enabled?",
       *[]() {
@@ -49,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",
@@ -113,11 +270,19 @@ void Init_ext()
     // begin operations
     .define_singleton_method(
       "_save",
-      *[](const Tensor &value) {
+      *[](const torch::IValue &value) {
         auto v = torch::pickle_save(value);
         std::string str(v.begin(), v.end());
         return str;
       })
+    .define_singleton_method(
+      "_load",
+      *[](const std::string &s) {
+        std::vector<char> v;
+        std::copy(s.begin(), s.end(), std::back_inserter(v));
+        // https://github.com/pytorch/pytorch/issues/20356#issuecomment-567663701
+        return torch::pickle_load(v);
+      })
     .define_singleton_method(
       "_binary_cross_entropy_with_logits",
       *[](const Tensor &input, const Tensor &target, OptionalTensor weight, OptionalTensor pos_weight, MyReduction reduction) {
@@ -213,6 +378,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) {
@@ -227,46 +407,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");
@@ -288,6 +462,7 @@ void Init_ext()
       });
 
   Class rb_cTensorOptions = define_class_under<torch::TensorOptions>(rb_mTorch, "TensorOptions")
+    .add_handler<torch::Error>(handle_error)
     .define_constructor(Constructor<torch::TensorOptions>())
     .define_method(
       "dtype",
@@ -311,13 +486,8 @@ void Init_ext()
     .define_method(
       "device",
       *[](torch::TensorOptions& self, std::string device) {
-        try {
-          // needed to catch exception
-          torch::Device d(device);
-          return self.device(d);
-        } catch (const c10::Error& error) {
-          throw std::runtime_error(error.what_without_backtrace());
-        }
+        torch::Device d(device);
+        return self.device(d);
       })
     .define_method(
       "requires_grad",
@@ -398,6 +568,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) {
@@ -407,6 +578,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(
@@ -418,6 +590,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);
 }