torch-rb 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9179470135a00453dcae9efbc6cd143112c5fec925bb5675a686e80e70b71b28
-  data.tar.gz: de365f50021d75338a78bcb6e0733bb430759fe7c4fcaea96b1ff0ed2a4b8d5d
+  metadata.gz: b37dc4dd7be5806879c2fb5bb52ac94c8b16eba76bc2a3c591ca4cbe51cf8745
+  data.tar.gz: 6415d14f7cc8baa4db9205c709b70fec2b90b4dff1b60de97c299c2a7edfbf40
 SHA512:
-  metadata.gz: 46d3d49aa63c0764d20178f450aa0b88c88938c194e70040650e6c1a29899e5f4d896671571730dc23eb1fe039ede53d2714db0f6fe7506ad4382653a5e6ec18
-  data.tar.gz: 3fe47be264030fc2d84de85bb7d006337df37fb5c41b147332fe37dd21de7ba61bdc53a0f7ae9085e01c992a643b22d8216a0248b7a4d24487d88fd7f88a9ecf
+  metadata.gz: cf43cb21e18171f76f1291f2cccdb8a93141605fe33d4421eaf799a4589638d33da040b2ffad3ddce34fec60ab2b41edf1fa9a247d69de7f31e157063e57f331
+  data.tar.gz: 3c858de8e7eb6169359fad18104c08d9a4011a305f44c4a8213a289b005dc4439b1959a40effd8b1bba1c2e96a871b28f01695fdda56e6ad0aeed0c2334cfa25

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 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

@@ -283,6 +283,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 = Net.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)):
@@ -445,6 +461,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,6 +23,11 @@ class Parameter: public torch::autograd::Variable {
     Parameter(Tensor&& t) : torch::autograd::Variable(t) { }
 };
 
+void handle_error(c10::Error const & ex)
+{
+  throw Exception(rb_eRuntimeError, ex.what_without_backtrace());
+}
+
 extern "C"
 void Init_ext()
 {
@@ -34,6 +40,108 @@ void Init_ext()
   Module rb_mNN = define_module_under(rb_mTorch, "NN");
   add_nn_functions(rb_mNN);
 
+  // https://pytorch.org/cppdocs/api/structc10_1_1_i_value.html
+  Class rb_cIValue = define_class_under<torch::IValue>(rb_mTorch, "IValue")
+    .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_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 h;
+        for (auto& pair : dict) {
+          h[to_ruby<torch::IValue>(torch::IValue{pair.key()})] = to_ruby<torch::IValue>(torch::IValue{pair.value()});
+        }
+        return h;
+      })
+    .define_singleton_method(
+      "from_tensor",
+      *[](torch::Tensor& v) {
+        return torch::IValue(v);
+      })
+    .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?",
       *[]() {
@@ -113,11 +221,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) {
@@ -157,6 +273,7 @@ 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)
@@ -288,6 +405,7 @@ void Init_ext()
       });
 
   Class rb_cTensorOptions = define_class_under<torch::TensorOptions>(rb_mTorch, "TensorOptions")
+    .add_handler<c10::Error>(handle_error)
     .define_constructor(Constructor<torch::TensorOptions>())
     .define_method(
       "dtype",
@@ -311,13 +429,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",

data/ext/torch/extconf.rb

@@ -10,19 +10,24 @@ $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"
 end
 
-# silence ruby/intern.h warning
-$CXXFLAGS << " -Wno-deprecated-register"
-
-# silence torch warnings
 if clang
+  # silence ruby/intern.h warning
+  $CXXFLAGS << " -Wno-deprecated-register"
+
+  # silence torch warnings
   $CXXFLAGS << " -Wno-shorten-64-to-32 -Wno-missing-noreturn"
 else
+  # silence rice warnings
+  $CXXFLAGS << " -Wno-noexcept-type"
+
+  # silence torch warnings
   $CXXFLAGS << " -Wno-duplicated-cond -Wno-suggest-attribute=noreturn"
 end
 
@@ -34,15 +39,20 @@ cuda_inc, cuda_lib = dir_config("cuda")
 cuda_inc ||= "/usr/local/cuda/include"
 cuda_lib ||= "/usr/local/cuda/lib64"
 
-with_cuda = Dir["#{lib}/*torch_cuda*"].any? && have_library("cuda") && have_library("cudnn")
+$LDFLAGS << " -L#{lib}" if Dir.exist?(lib)
+abort "LibTorch not found" unless have_library("torch")
+
+with_cuda = false
+if Dir["#{lib}/*torch_cuda*"].any?
+  $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"
 
 $LDFLAGS << " -Wl,-rpath,#{lib}"
 $LDFLAGS << ":#{cuda_lib}/stubs:#{cuda_lib}" if with_cuda
-$LDFLAGS << " -L#{lib}"
-$LDFLAGS << " -L#{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"

data/lib/torch/nn/module.rb

@@ -67,8 +67,9 @@ module Torch
         self
       end
 
-      def cuda(device: nil)
-        _apply ->(t) { t.cuda(device) }
+      # TODO add device
+      def cuda
+        _apply ->(t) { t.cuda }
       end
 
       def cpu
@@ -112,8 +113,28 @@ module Torch
         destination
       end
 
+      # TODO add strict option
+      # TODO match PyTorch behavior
       def load_state_dict(state_dict)
-        raise NotImplementedYet
+        state_dict.each do |k, input_param|
+          k1, k2 = k.split(".", 2)
+          mod = named_modules[k1]
+          if mod.is_a?(Module)
+            param = mod.named_parameters[k2]
+            if param.is_a?(Parameter)
+              Torch.no_grad do
+                param.copy!(input_param)
+              end
+            else
+              raise Error, "Unknown parameter: #{k1}"
+            end
+          else
+            raise Error, "Unknown module: #{k1}"
+          end
+        end
+
+        # TODO return missing keys and unexpected keys
+        nil
       end
 
       def parameters

data/lib/torch/tensor.rb

@@ -37,6 +37,10 @@ module Torch
       to("cpu")
     end
 
+    def cuda
+      to("cuda")
+    end
+
     def size(dim = nil)
       if dim
         _size_int(dim)

data/lib/torch/version.rb

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

data/lib/torch.rb

@@ -317,12 +317,11 @@ module Torch
     end
 
     def save(obj, f)
-      raise NotImplementedYet unless obj.is_a?(Tensor)
-      File.binwrite(f, _save(obj))
+      File.binwrite(f, _save(to_ivalue(obj)))
     end
 
     def load(f)
-      raise NotImplementedYet
+      to_ruby(_load(File.binread(f)))
     end
 
     # --- begin tensor creation: https://pytorch.org/cppdocs/notes/tensor_creation.html ---
@@ -447,6 +446,94 @@ module Torch
 
     private
 
+    def to_ivalue(obj)
+      case obj
+      when String
+        IValue.from_string(obj)
+      when Integer
+        IValue.from_int(obj)
+      when Tensor
+        IValue.from_tensor(obj)
+      when Float
+        IValue.from_double(obj)
+      when Hash
+        dict = {}
+        obj.each do |k, v|
+          dict[to_ivalue(k)] = to_ivalue(v)
+        end
+        IValue.from_dict(dict)
+      when true, false
+        IValue.from_bool(obj)
+      when nil
+        IValue.new
+      else
+        raise Error, "Unknown type: #{obj.class.name}"
+      end
+    end
+
+    def to_ruby(ivalue)
+      if ivalue.bool?
+        ivalue.to_bool
+      elsif ivalue.double?
+        ivalue.to_double
+      elsif ivalue.int?
+        ivalue.to_int
+      elsif ivalue.none?
+        nil
+      elsif ivalue.string?
+        ivalue.to_string_ref
+      elsif ivalue.tensor?
+        ivalue.to_tensor
+      elsif ivalue.generic_dict?
+        dict = {}
+        ivalue.to_generic_dict.each do |k, v|
+          dict[to_ruby(k)] = to_ruby(v)
+        end
+        dict
+      else
+        type =
+          if ivalue.capsule?
+            "Capsule"
+          elsif ivalue.custom_class?
+            "CustomClass"
+          elsif ivalue.tuple?
+            "Tuple"
+          elsif ivalue.future?
+            "Future"
+          elsif ivalue.r_ref?
+            "RRef"
+          elsif ivalue.int_list?
+            "IntList"
+          elsif ivalue.double_list?
+            "DoubleList"
+          elsif ivalue.bool_list?
+            "BoolList"
+          elsif ivalue.tensor_list?
+            "TensorList"
+          elsif ivalue.list?
+            "List"
+          elsif ivalue.object?
+            "Object"
+          elsif ivalue.module?
+            "Module"
+          elsif ivalue.py_object?
+            "PyObject"
+          elsif ivalue.scalar?
+            "Scalar"
+          elsif ivalue.device?
+            "Device"
+          # elsif ivalue.generator?
+          #   "Generator"
+          elsif ivalue.ptr_type?
+            "PtrType"
+          else
+            "Unknown"
+          end
+
+        raise Error, "Unsupported type: #{type}"
+      end
+    end
+
     def tensor_size(size)
       size.flatten
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-23 00:00:00.000000000 Z
+date: 2020-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -120,17 +120,10 @@ files:
 - README.md
 - ext/torch/ext.cpp
 - ext/torch/extconf.rb
-- ext/torch/nn_functions.cpp
-- ext/torch/nn_functions.hpp
 - ext/torch/templates.cpp
 - ext/torch/templates.hpp
-- ext/torch/tensor_functions.cpp
-- ext/torch/tensor_functions.hpp
-- ext/torch/torch_functions.cpp
-- ext/torch/torch_functions.hpp
 - lib/torch-rb.rb
 - lib/torch.rb
-- lib/torch/ext.bundle
 - lib/torch/hub.rb
 - lib/torch/inspector.rb
 - lib/torch/native/dispatcher.rb