torch-rb 0.1.8 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fca87cb9b6d255287e9fafadf786c113798abbe76b36c82b8271b79cfbf3c2b9
-  data.tar.gz: 4813c71f5ad6d078e78da03cf59f8036e9e76258ffb67f538899bba146dcba2a
+  metadata.gz: 9179470135a00453dcae9efbc6cd143112c5fec925bb5675a686e80e70b71b28
+  data.tar.gz: de365f50021d75338a78bcb6e0733bb430759fe7c4fcaea96b1ff0ed2a4b8d5d
 SHA512:
-  metadata.gz: 22c7150e6a7d9132c40c67819beecc6b8c69b268bd227a8e4aa324ef5e2707004691d5b65dcd4ba1ac537bfaf783947da7e5a323417cffcbf7d348768c40b7c6
-  data.tar.gz: 8a86c6b68efe6ad85a261d7033b87f040c22b2c670a0238accd6246274caed17b86d7b424441bba80c5ea67ec1bf53b05444dfb0c45ea5b8a52806d0ce19ec1e
+  metadata.gz: 46d3d49aa63c0764d20178f450aa0b88c88938c194e70040650e6c1a29899e5f4d896671571730dc23eb1fe039ede53d2714db0f6fe7506ad4382653a5e6ec18
+  data.tar.gz: 3fe47be264030fc2d84de85bb7d006337df37fb5c41b147332fe37dd21de7ba61bdc53a0f7ae9085e01c992a643b22d8216a0248b7a4d24487d88fd7f88a9ecf

data/CHANGELOG.md

@@ -1,7 +1,16 @@
+## 0.2.0 (2020-04-22)
+
+- No longer experimental
+- Updated libtorch to 1.5.0
+- Added support for GPUs and OpenMP
+- Added adaptive pooling layers
+- Tensor `dtype` is now based on Numo type for `Torch.tensor`
+- Improved support for boolean tensors
+- Fixed error with unbiased linear model
+
 ## 0.1.8 (2020-01-17)
 
-- Added support for libtorch 1.4.0
-- Dropped support for libtorch 1.3.1
+- Updated libtorch to 1.4.0
 
 ## 0.1.7 (2020-01-10)
 

data/README.md

@@ -1,10 +1,8 @@
-# Torch-rb
+# Torch.rb
 
 :fire: Deep learning for Ruby, powered by [LibTorch](https://pytorch.org)
 
-This gem is currently experimental. There may be breaking changes between each release. Please report any issues you experience.
-
-[![Build Status](https://travis-ci.org/ankane/torch-rb.svg?branch=master)](https://travis-ci.org/ankane/torch-rb)
+[![Build Status](https://travis-ci.org/ankane/torch.rb.svg?branch=master)](https://travis-ci.org/ankane/torch.rb)
 
 ## Installation
 
@@ -30,8 +28,6 @@ This library follows the [PyTorch API](https://pytorch.org/docs/stable/torch.htm
 - Methods that return booleans use `?` instead of `is_`  (`tensor?` instead of `is_tensor`)
 - Numo is used instead of NumPy (`x.numo` instead of `x.numpy()`)
 
-Some methods and options are missing at the moment. PRs welcome!
-
 ## Tutorial
 
 Some examples below are from [Deep Learning with PyTorch: A 60 Minutes Blitz](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)
@@ -379,6 +375,14 @@ Here are a few full examples:
 bundle config build.torch-rb --with-torch-dir=/path/to/libtorch
 ```
 
+Here’s the list of compatible versions.
+
+Torch.rb | LibTorch
+--- | ---
+0.2.0 | 1.5.0
+0.1.8 | 1.4.0
+0.1.0-0.1.7 | 1.3.1
+
 ### Homebrew
 
 For Mac, you can use Homebrew.
@@ -389,6 +393,26 @@ brew install libtorch
 
 Then install the gem (no need for `bundle config`).
 
+## Performance
+
+### 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.
+
+Check if CUDA is available
+
+```ruby
+Torch::CUDA.available?
+```
+
+Move a neural network to a GPU
+
+```ruby
+net.to("cuda")
+```
+
 ## rbenv
 
 This library uses [Rice](https://github.com/jasonroelofs/rice) to interface with LibTorch. Rice and earlier versions of rbenv don’t play nicely together. If you encounter an error during installation, upgrade ruby-build and reinstall your Ruby version.
@@ -400,22 +424,22 @@ rbenv install [version]
 
 ## History
 
-View the [changelog](https://github.com/ankane/torch-rb/blob/master/CHANGELOG.md)
+View the [changelog](https://github.com/ankane/torch.rb/blob/master/CHANGELOG.md)
 
 ## Contributing
 
 Everyone is encouraged to help improve this project. Here are a few ways you can help:
 
-- [Report bugs](https://github.com/ankane/torch-rb/issues)
-- Fix bugs and [submit pull requests](https://github.com/ankane/torch-rb/pulls)
+- [Report bugs](https://github.com/ankane/torch.rb/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/torch.rb/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
 
 To get started with development:
 
 ```sh
-git clone https://github.com/ankane/torch-rb.git
-cd torch-rb
+git clone https://github.com/ankane/torch.rb.git
+cd torch.rb
 bundle install
 bundle exec rake compile -- --with-torch-dir=/path/to/libtorch
 bundle exec rake test

data/ext/torch/ext.cpp

@@ -131,12 +131,15 @@ void Init_ext()
       })
     .define_singleton_method(
       "_tensor",
-      *[](Object o, IntArrayRef size, const torch::TensorOptions &options) {
-        Array a = Array(o);
+      *[](Array a, IntArrayRef size, const torch::TensorOptions &options) {
         auto dtype = options.dtype();
         torch::Tensor t;
         if (dtype == torch::kBool) {
-          throw std::runtime_error("Cannot create bool from tensor method yet");
+          std::vector<uint8_t> vec;
+          for (size_t i = 0; i < a.size(); i++) {
+            vec.push_back(from_ruby<bool>(a[i]));
+          }
+          t = torch::tensor(vec, options);
         } else {
           std::vector<float> vec;
           for (size_t i = 0; i < a.size(); i++) {
@@ -213,48 +216,56 @@ void Init_ext()
     .define_method(
       "_flat_data",
       *[](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);
+        }
+
         Array a;
-        auto dtype = self.dtype();
+        auto dtype = tensor.dtype();
 
         // TODO DRY if someone knows C++
         if (dtype == torch::kByte) {
-          uint8_t* data = self.data_ptr<uint8_t>();
-          for (int i = 0; i < self.numel(); i++) {
+          uint8_t* data = tensor.data_ptr<uint8_t>();
+          for (int i = 0; i < tensor.numel(); i++) {
             a.push(data[i]);
           }
         } else if (dtype == torch::kChar) {
-          int8_t* data = self.data_ptr<int8_t>();
-          for (int i = 0; i < self.numel(); i++) {
+          int8_t* data = tensor.data_ptr<int8_t>();
+          for (int i = 0; i < tensor.numel(); i++) {
             a.push(to_ruby<int>(data[i]));
           }
         } else if (dtype == torch::kShort) {
-          int16_t* data = self.data_ptr<int16_t>();
-          for (int i = 0; i < self.numel(); i++) {
+          int16_t* data = tensor.data_ptr<int16_t>();
+          for (int i = 0; i < tensor.numel(); i++) {
             a.push(data[i]);
           }
         } else if (dtype == torch::kInt) {
-          int32_t* data = self.data_ptr<int32_t>();
-          for (int i = 0; i < self.numel(); i++) {
+          int32_t* data = tensor.data_ptr<int32_t>();
+          for (int i = 0; i < tensor.numel(); i++) {
             a.push(data[i]);
           }
         } else if (dtype == torch::kLong) {
-          int64_t* data = self.data_ptr<int64_t>();
-          for (int i = 0; i < self.numel(); i++) {
+          int64_t* data = tensor.data_ptr<int64_t>();
+          for (int i = 0; i < tensor.numel(); i++) {
             a.push(data[i]);
           }
         } else if (dtype == torch::kFloat) {
-          float* data = self.data_ptr<float>();
-          for (int i = 0; i < self.numel(); i++) {
+          float* data = tensor.data_ptr<float>();
+          for (int i = 0; i < tensor.numel(); i++) {
             a.push(data[i]);
           }
         } else if (dtype == torch::kDouble) {
-          double* data = self.data_ptr<double>();
-          for (int i = 0; i < self.numel(); i++) {
+          double* data = tensor.data_ptr<double>();
+          for (int i = 0; i < tensor.numel(); i++) {
             a.push(data[i]);
           }
         } else if (dtype == torch::kBool) {
-          bool* data = self.data_ptr<bool>();
-          for (int i = 0; i < self.numel(); i++) {
+          bool* data = tensor.data_ptr<bool>();
+          for (int i = 0; i < tensor.numel(); i++) {
             a.push(data[i] ? True : False);
           }
         } else {
@@ -300,15 +311,13 @@ void Init_ext()
     .define_method(
       "device",
       *[](torch::TensorOptions& self, std::string device) {
-        torch::DeviceType d;
-        if (device == "cpu") {
-          d = torch::kCPU;
-        } else if (device == "cuda") {
-          d = torch::kCUDA;
-        } else {
-          throw std::runtime_error("Unsupported device: " + 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());
         }
-        return self.device(d);
       })
     .define_method(
       "requires_grad",

data/ext/torch/extconf.rb

@@ -2,28 +2,55 @@ require "mkmf-rice"
 
 abort "Missing stdc++" unless have_library("stdc++")
 
-$CXXFLAGS << " -std=c++11"
+$CXXFLAGS << " -std=c++14"
 
-# needed for Linux pre-cxx11 ABI version
-# $CXXFLAGS << " -D_GLIBCXX_USE_CXX11_ABI=0"
+# change to 0 for Linux pre-cxx11 ABI version
+$CXXFLAGS << " -D_GLIBCXX_USE_CXX11_ABI=1"
+
+# TODO check compiler name
+clang = RbConfig::CONFIG["host_os"] =~ /darwin/i
+
+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
-$CXXFLAGS << " -Wno-shorten-64-to-32 -Wno-missing-noreturn"
+if clang
+  $CXXFLAGS << " -Wno-shorten-64-to-32 -Wno-missing-noreturn"
+else
+  $CXXFLAGS << " -Wno-duplicated-cond -Wno-suggest-attribute=noreturn"
+end
 
 inc, lib = dir_config("torch")
-
 inc ||= "/usr/local/include"
 lib ||= "/usr/local/lib"
 
+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")
+
 $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 << " -ltorch -lc10"
+$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"
+if with_cuda
+  $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"
+end
 
 # generate C++ functions
 puts "Generating C++ functions..."