torch-rb 0.6.0 → 0.7.0

data/ext/torch/torch.cpp

@@ -1,6 +1,6 @@
 #include <torch/torch.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "torch_functions.h"
 #include "templates.h"
@@ -9,69 +9,78 @@
 void init_torch(Rice::Module& m) {
   m.add_handler<torch::Error>(handle_error);
   add_torch_functions(m);
-  m.define_singleton_method(
+  m.define_singleton_function(
       "grad_enabled?",
-      *[]() {
+      []() {
         return torch::GradMode::is_enabled();
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_set_grad_enabled",
-      *[](bool enabled) {
+      [](bool enabled) {
         torch::GradMode::set_enabled(enabled);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "manual_seed",
-      *[](uint64_t seed) {
+      [](uint64_t seed) {
         return torch::manual_seed(seed);
       })
     // config
-    .define_singleton_method(
+    .define_singleton_function(
       "show_config",
-      *[] {
+      [] {
         return torch::show_config();
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "parallel_info",
-      *[] {
+      [] {
         return torch::get_parallel_info();
       })
     // begin operations
-    .define_singleton_method(
+    .define_singleton_function(
       "_save",
-      *[](const torch::IValue &value) {
+      [](const torch::IValue &value) {
         auto v = torch::pickle_save(value);
         std::string str(v.begin(), v.end());
         return str;
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_load",
-      *[](const std::string &s) {
+      [](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(
+    .define_singleton_function(
       "_from_blob",
-      *[](Rice::String s, std::vector<int64_t> size, const torch::TensorOptions &options) {
+      [](Rice::String s, std::vector<int64_t> size, const torch::TensorOptions &options) {
         void *data = const_cast<char *>(s.c_str());
         return torch::from_blob(data, size, options);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_tensor",
-      *[](Rice::Array a, std::vector<int64_t> size, const torch::TensorOptions &options) {
+      [](Rice::Array a, std::vector<int64_t> size, const torch::TensorOptions &options) {
         auto dtype = options.dtype();
         torch::Tensor t;
         if (dtype == torch::kBool) {
           std::vector<uint8_t> vec;
           for (long i = 0; i < a.size(); i++) {
-            vec.push_back(from_ruby<bool>(a[i]));
+            vec.push_back(Rice::detail::From_Ruby<bool>().convert(a[i].value()));
+          }
+          t = torch::tensor(vec, options);
+        } else if (dtype == torch::kComplexFloat || dtype == torch::kComplexDouble) {
+          // TODO use template
+          std::vector<c10::complex<double>> vec;
+          Object obj;
+          for (long i = 0; i < a.size(); i++) {
+            obj = a[i];
+            vec.push_back(c10::complex<double>(Rice::detail::From_Ruby<double>().convert(obj.call("real").value()), Rice::detail::From_Ruby<double>().convert(obj.call("imag").value())));
           }
           t = torch::tensor(vec, options);
         } else {
           std::vector<float> vec;
           for (long i = 0; i < a.size(); i++) {
-            vec.push_back(from_ruby<float>(a[i]));
+            vec.push_back(Rice::detail::From_Ruby<float>().convert(a[i].value()));
           }
           // hack for requires_grad error
           if (options.requires_grad()) {

data/ext/torch/utils.h

@@ -1,11 +1,10 @@
 #pragma once
 
-#include <rice/Exception.hpp>
-#include <rice/Symbol.hpp>
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
 
 // TODO find better place
-inline void handle_error(torch::Error const & ex)
-{
+inline void handle_error(torch::Error const & ex) {
   throw Rice::Exception(rb_eRuntimeError, ex.what_without_backtrace());
 }
 

data/ext/torch/wrap_outputs.h

@@ -1,99 +1,106 @@
 #pragma once
 
 #include <torch/torch.h>
-#include <rice/Object.hpp>
+#include <rice/rice.hpp>
 
-inline Object wrap(bool x) {
-  return to_ruby<bool>(x);
+inline VALUE wrap(bool x) {
+  return Rice::detail::To_Ruby<bool>().convert(x);
 }
 
-inline Object wrap(int64_t x) {
-  return to_ruby<int64_t>(x);
+inline VALUE wrap(int64_t x) {
+  return Rice::detail::To_Ruby<int64_t>().convert(x);
 }
 
-inline Object wrap(double x) {
-  return to_ruby<double>(x);
+inline VALUE wrap(double x) {
+  return Rice::detail::To_Ruby<double>().convert(x);
 }
 
-inline Object wrap(torch::Tensor x) {
-  return to_ruby<torch::Tensor>(x);
+inline VALUE wrap(torch::Tensor x) {
+  return Rice::detail::To_Ruby<torch::Tensor>().convert(x);
 }
 
-inline Object wrap(torch::Scalar x) {
-  return to_ruby<torch::Scalar>(x);
+inline VALUE wrap(torch::Scalar x) {
+  return Rice::detail::To_Ruby<torch::Scalar>().convert(x);
 }
 
-inline Object wrap(torch::ScalarType x) {
-  return to_ruby<torch::ScalarType>(x);
+inline VALUE wrap(torch::ScalarType x) {
+  return Rice::detail::To_Ruby<torch::ScalarType>().convert(x);
 }
 
-inline Object wrap(torch::QScheme x) {
-  return to_ruby<torch::QScheme>(x);
+inline VALUE wrap(torch::QScheme x) {
+  return Rice::detail::To_Ruby<torch::QScheme>().convert(x);
 }
 
-inline Object wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
-  Array a;
-  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
-  return Object(a);
+inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor> x) {
+  return rb_ary_new3(
+    2,
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x))
+  );
 }
 
-inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  Array a;
-  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<2>(x)));
-  return Object(a);
+inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor> x) {
+  return rb_ary_new3(
+    3,
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<2>(x))
+  );
 }
 
-inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  Array a;
-  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<2>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<3>(x)));
-  return Object(a);
+inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
+  return rb_ary_new3(
+    4,
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<2>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<3>(x))
+  );
 }
 
-inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
-  Array a;
-  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<2>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<3>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<4>(x)));
-  return Object(a);
+inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor> x) {
+  return rb_ary_new3(
+    5,
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<2>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<3>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<4>(x))
+  );
 }
 
-inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x) {
-  Array a;
-  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<2>(x)));
-  a.push(to_ruby<int64_t>(std::get<3>(x)));
-  return Object(a);
+inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, int64_t> x) {
+  return rb_ary_new3(
+    4,
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<2>(x)),
+    Rice::detail::To_Ruby<int64_t>().convert(std::get<3>(x))
+  );
 }
 
-inline Object wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
-  Array a;
-  a.push(to_ruby<torch::Tensor>(std::get<0>(x)));
-  a.push(to_ruby<torch::Tensor>(std::get<1>(x)));
-  a.push(to_ruby<double>(std::get<2>(x)));
-  a.push(to_ruby<int64_t>(std::get<3>(x)));
-  return Object(a);
+inline VALUE wrap(std::tuple<torch::Tensor, torch::Tensor, double, int64_t> x) {
+  return rb_ary_new3(
+    4,
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<0>(x)),
+    Rice::detail::To_Ruby<torch::Tensor>().convert(std::get<1>(x)),
+    Rice::detail::To_Ruby<double>().convert(std::get<2>(x)),
+    Rice::detail::To_Ruby<int64_t>().convert(std::get<3>(x))
+  );
 }
 
-inline Object wrap(torch::TensorList x) {
-  Array a;
-  for (auto& t : x) {
-    a.push(to_ruby<torch::Tensor>(t));
+inline VALUE wrap(torch::TensorList x) {
+  auto a = rb_ary_new2(x.size());
+  for (auto t : x) {
+    rb_ary_push(a, Rice::detail::To_Ruby<torch::Tensor>().convert(t));
   }
-  return Object(a);
+  return a;
 }
 
-inline Object wrap(std::tuple<double, double> x) {
-  Array a;
-  a.push(to_ruby<double>(std::get<0>(x)));
-  a.push(to_ruby<double>(std::get<1>(x)));
-  return Object(a);
+inline VALUE wrap(std::tuple<double, double> x) {
+  return rb_ary_new3(
+    2,
+    Rice::detail::To_Ruby<double>().convert(std::get<0>(x)),
+    Rice::detail::To_Ruby<double>().convert(std::get<1>(x))
+  );
 }

data/lib/torch.rb

@@ -238,8 +238,11 @@ module Torch
     double: 7,
     float64: 7,
     complex_half: 8,
+    complex32: 8,
     complex_float: 9,
+    complex64: 9,
     complex_double: 10,
+    complex128: 10,
     bool: 11,
     qint8: 12,
     quint8: 13,
@@ -394,6 +397,8 @@ module Torch
           options[:dtype] = :int64
         elsif data.all? { |v| v == true || v == false }
           options[:dtype] = :bool
+        elsif data.any? { |v| v.is_a?(Complex) }
+          options[:dtype] = :complex64
         end
       end
 

data/lib/torch/inspector.rb

@@ -96,8 +96,11 @@ module Torch
             ret = "%.#{PRINT_OPTS[:precision]}f" % value
           end
         elsif @complex_dtype
-          p = PRINT_OPTS[:precision]
-          raise NotImplementedYet
+          # TODO use float formatter for each part
+          precision = PRINT_OPTS[:precision]
+          imag = value.imag
+          sign = imag >= 0 ? "+" : "-"
+          ret = "%.#{precision}f#{sign}%.#{precision}fi" % [value.real, value.imag.abs]
         else
           ret = value.to_s
         end

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-26 00:00:00.000000000 Z
+date: 2021-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: 4.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: 4.0.2
 description:
 email: andrew@ankane.org
 executables: []