torch-rb 0.13.2 → 0.14.1

data/ext/torch/ruby_arg_parser.cpp

@@ -401,7 +401,7 @@ void FunctionParameter::set_default_str(const std::string& str) {
     if (str != "None") {
       throw std::runtime_error("default value for Tensor must be none, got: " + str);
     }
-  } else if (type_ == ParameterType::INT64) {
+  } else if (type_ == ParameterType::INT64 || type_ == ParameterType::SYM_INT) {
     default_int = atol(str.c_str());
   } else if (type_ == ParameterType::BOOL) {
     default_bool = (str == "True" || str == "true");
@@ -417,7 +417,7 @@ void FunctionParameter::set_default_str(const std::string& str) {
       default_scalar = as_integer.has_value() ? at::Scalar(as_integer.value()) :
                                                 at::Scalar(atof(str.c_str()));
     }
-  } else if (type_ == ParameterType::INT_LIST) {
+  } else if (type_ == ParameterType::INT_LIST || type_ == ParameterType::SYM_INT_LIST) {
     if (str != "None") {
       default_intlist = parse_intlist_args(str, size);
     }
@@ -452,6 +452,31 @@ void FunctionParameter::set_default_str(const std::string& str) {
       default_string = parse_string_literal(str);
     }
   }
+  // These types weren't handled here before. Adding a default error
+  // led to a lot of test failures so adding this skip for now.
+  // We should correctly handle these though because it might be causing
+  // silent failures.
+  else if (type_ == ParameterType::TENSOR_LIST) {
+    // throw std::runtime_error("Invalid Tensor List");
+  } else if (type_ == ParameterType::GENERATOR) {
+    // throw std::runtime_error("ParameterType::GENERATOR");
+  } else if (type_ == ParameterType::PYOBJECT) {
+    // throw std::runtime_error("ParameterType::PYOBJECT");
+  } else if (type_ == ParameterType::MEMORY_FORMAT) {
+    // throw std::runtime_error("ParameterType::MEMORY_FORMAT");
+  } else if (type_ == ParameterType::DIMNAME) {
+    // throw std::runtime_error("ParameterType::DIMNAME");
+  } else if (type_ == ParameterType::DIMNAME_LIST) {
+    // throw std::runtime_error("ParameterType::DIMNAME_LIST");
+  } else if (type_ == ParameterType::SCALAR_LIST) {
+    // throw std::runtime_error("ParameterType::SCALAR_LIST");
+  } else if (type_ == ParameterType::STORAGE) {
+    // throw std::runtime_error("ParameterType::STORAGE");
+  } else if (type_ == ParameterType::QSCHEME) {
+    // throw std::runtime_error("ParameterType::QSCHEME");
+  } else {
+    throw std::runtime_error("unknown parameter type");
+  }
 }
 
 FunctionSignature::FunctionSignature(const std::string& fmt, int index)

data/ext/torch/torch.cpp

@@ -2,6 +2,8 @@
 
 #include <rice/rice.hpp>
 
+#include <fstream>
+
 #include "torch_functions.h"
 #include "templates.h"
 #include "utils.h"
@@ -57,16 +59,18 @@ void init_torch(Rice::Module& m) {
       "_save",
       [](const torch::IValue &value) {
         auto v = torch::pickle_save(value);
-        std::string str(v.begin(), v.end());
-        return str;
+        return Object(rb_str_new(v.data(), v.size()));
       })
     .define_singleton_function(
       "_load",
-      [](const std::string &s) {
-        std::vector<char> v;
-        std::copy(s.begin(), s.end(), std::back_inserter(v));
+      [](const std::string &filename) {
         // https://github.com/pytorch/pytorch/issues/20356#issuecomment-567663701
-        return torch::pickle_load(v);
+        std::ifstream input(filename, std::ios::binary);
+        std::vector<char> bytes(
+            (std::istreambuf_iterator<char>(input)),
+            (std::istreambuf_iterator<char>()));
+        input.close();
+        return torch::pickle_load(bytes);
       })
     .define_singleton_function(
       "_from_blob",

data/ext/torch/utils.h

@@ -6,7 +6,7 @@
 #include <rice/stl.hpp>
 
 static_assert(
-  TORCH_VERSION_MAJOR == 2 && TORCH_VERSION_MINOR == 0,
+  TORCH_VERSION_MAJOR == 2 && TORCH_VERSION_MINOR == 1,
   "Incompatible LibTorch version"
 );
 

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.13.2"
+  VERSION = "0.14.1"
 end

data/lib/torch.rb

@@ -387,8 +387,11 @@ module Torch
       File.binwrite(f, _save(to_ivalue(obj)))
     end
 
-    def load(f)
-      to_ruby(_load(File.binread(f)))
+    def load(filename)
+      # keep backwards compatibility
+      File.open(filename, "rb") { |f| f.read(1) }
+
+      to_ruby(_load(filename))
     end
 
     def tensor(data, **options)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.14.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-12 00:00:00.000000000 Z
+date: 2023-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -237,7 +237,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Deep learning for Ruby, powered by LibTorch