torch-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38e16e7f07d004fd9625f168694356d551c79cbc62b0131fe1403e4c0995f296
+  data.tar.gz: 66bf6ae0e4dd373a7542fbfb1cfb9dbd89fc455e16166e6a76d0945b32fecf38
+SHA512:
+  metadata.gz: d100e3a21ac877fe93ac61e9b5e0d8a5e61126684fc037dda3e9f703b040188b1e1523aa4111dff4aaf92ada1001597c5f60674b9583b14d31afd18dbf1ff18d
+  data.tar.gz: c234dee79e26d3ee25ade2aaddd75f155dea6d59d8b9c5af2c571423a7aaa8a6489f5cfce89f09f390468a951b1644a4212c19525a79816be09214f0938860a8

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2019-11-26)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2019 Andrew Kane
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,363 @@
+# Torch-rb
+
+:fire: Deep learning for Ruby, powered by [LibTorch](https://pytorch.org)
+
+**Note:** This gem is currently experimental. There may be breaking changes between each release.
+
+## Installation
+
+First, [install LibTorch](#libtorch-installation). For Homebrew, use:
+
+```sh
+brew install ankane/brew/libtorch
+```
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'torch-rb'
+```
+
+## Getting Started
+
+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_`)
+- 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()`)
+
+Many methods and options are missing at the moment. PRs welcome!
+
+Some examples below are from [Deep Learning with PyTorch: A 60 Minutes Blitz](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html).
+
+### Tensors
+
+Create a tensor from a Ruby array
+
+```ruby
+x = Torch.tensor([[1, 2, 3], [4, 5, 6]])
+```
+
+Get the shape of a tensor
+
+```ruby
+x.shape
+```
+
+There are [many functions](#tensor-creation) to create tensors, like
+
+```ruby
+a = Torch.rand(3)
+b = Torch.zeros(2, 3)
+```
+
+Each tensor has four properties
+
+- `dtype` - the data type - `:uint8`, `:int8`, `:int16`, `:int32`, `:int64`, `:float32`, `float64`, or `:bool`
+- `layout` - `:strided` (dense) or `:sparse`
+- `device` - the compute device, like CPU or GPU
+- `requires_grad` - whether or not to record gradients
+
+You can specify properties when creating a tensor
+
+```ruby
+Torch.rand(2, 3, dtype: :double, layout: :strided, device: "cpu", requires_grad: true)
+```
+
+### Operations
+
+Create a tensor
+
+```ruby
+x = Torch.tensor([10, 20, 30])
+```
+
+Add
+
+```ruby
+x + 5 # tensor([15, 25, 35])
+```
+
+Subtract
+
+```ruby
+x - 5 # tensor([5, 15, 25])
+```
+
+Multiply
+
+```ruby
+x * 5 # tensor([50, 100, 150])
+```
+
+Divide
+
+```ruby
+x / 5 # tensor([2, 4, 6])
+```
+
+Get the remainder
+
+```ruby
+x % 3 # tensor([1, 2, 0])
+```
+
+Raise to a power
+
+```ruby
+x**2 # tensor([100, 400, 900])
+```
+
+Perform operations with other tensors
+
+```ruby
+y = Torch.tensor([1, 2, 3])
+x + y # tensor([11, 22, 33])
+```
+
+Perform operations in-place
+
+```ruby
+x.add!(5)
+x # tensor([15, 25, 35])
+```
+
+You can also specify an output tensor
+
+```ruby
+result = Torch.empty(3)
+Torch.add(x, y, out: result)
+result # tensor([15, 25, 35])
+```
+
+### Numo
+
+Convert a tensor to a Numo array
+
+```ruby
+a = Torch.ones(5)
+a.numo
+```
+
+Convert a Numo array to a tensor
+
+```ruby
+b = Numo::NArray.cast([1, 2, 3])
+Torch.from_numpy(b)
+```
+
+### Autograd
+
+Create a tensor with `requires_grad: true`
+
+```ruby
+x = Torch.ones(2, 2, requires_grad: true)
+```
+
+Perform operations
+
+```ruby
+y = x + 2
+z = y * y * 3
+out = z.mean
+```
+
+Backprop
+
+```ruby
+out.backward
+```
+
+Get gradients
+
+```ruby
+x.grad
+```
+
+Stop autograd from tracking history
+
+```ruby
+x.requires_grad # true
+(x ** 2).requires_grad # true
+
+Torch.no_grad do
+  (x ** 2).requires_grad # false
+end
+```
+
+### Neural Networks
+
+Define a neural network
+
+```ruby
+class Net < Torch::NN::Module
+  def initialize
+    super
+    @conv1 = Torch::NN::Conv2d.new(1, 6, 3)
+    @conv2 = Torch::NN::Conv2d.new(6, 16, 3)
+    @fc1 = Torch::NN::Linear.new(16 * 6 * 6, 120)
+    @fc2 = Torch::NN::Linear.new(120, 84)
+    @fc3 = Torch::NN::Linear.new(84, 10)
+  end
+
+  def forward(x)
+    x = Torch::NN::F.max_pool2d(Torch::NN::F.relu(@conv1.call(x)), [2, 2])
+    x = Torch::NN::F.max_pool2d(Torch::NN::F.relu(@conv2.call(x)), 2)
+    x = x.view(-1, num_flat_features(x))
+    x = Torch::NN::F.relu(@fc1.call(x))
+    x = Torch::NN::F.relu(@fc2.call(x))
+    x = @fc3.call(x)
+    x
+  end
+
+  def num_flat_features(x)
+    size = x.size[1..-1]
+    num_features = 1
+    size.each do |s|
+      num_features *= s
+    end
+    num_features
+  end
+end
+```
+
+And run
+
+```ruby
+net = Net.new
+input = Torch.randn(1, 1, 32, 32)
+net.call(input)
+```
+
+### Tensor Creation
+
+Here’s a list of functions to create tensors (descriptions from the [C++ docs](https://pytorch.org/cppdocs/notes/tensor_creation.html)):
+
+- `arange` returns a tensor with a sequence of integers
+
+  ```ruby
+  Torch.arange(3) # tensor([0, 1, 2])
+  ```
+
+- `empty` returns a tensor with uninitialized values
+
+  ```ruby
+  Torch.empty(3)
+  ```
+
+- `eye` returns an identity matrix
+
+  ```ruby
+  Torch.eye(2) # tensor([[1, 0], [0, 1]])
+  ```
+
+- `full` returns a tensor filled with a single value
+
+  ```ruby
+  Torch.full([3], 5) # tensor([5, 5, 5])
+  ```
+
+- `linspace` returns a tensor with values linearly spaced in some interval
+
+  ```ruby
+  Torch.linspace(0, 10, 5) # tensor([0, 5, 10])
+  ```
+
+- `logspace` returns a tensor with values logarithmically spaced in some interval
+
+  ```ruby
+  Torch.logspace(0, 10, 5) # tensor([1, 1e5, 1e10])
+  ```
+
+- `ones` returns a tensor filled with all ones
+
+  ```ruby
+  Torch.ones(3) # tensor([1, 1, 1])
+  ```
+
+- `rand` returns a tensor filled with values drawn from a uniform distribution on [0, 1)
+
+  ```ruby
+  Torch.rand(3)
+  ```
+
+- `randint` returns a tensor with integers randomly drawn from an interval
+
+  ```ruby
+  Torch.randint(1, 10, [3])
+  ```
+
+- `randn` returns a tensor filled with values drawn from a unit normal distribution
+
+  ```ruby
+  Torch.randn(3)
+  ```
+
+- `randperm` returns a tensor filled with a random permutation of integers in some interval
+
+  ```ruby
+  Torch.randperm(3) # tensor([2, 0, 1])
+  ```
+
+- `zeros` returns a tensor filled with all zeros
+
+  ```ruby
+  Torch.zeros(3) # tensor([0, 0, 0])
+  ```
+
+## LibTorch Installation
+
+[Download LibTorch](https://pytorch.org/) and run:
+
+```sh
+gem install torch-rb -- --with-torch-dir=/path/to/libtorch
+```
+
+### Homebrew
+
+For Mac, you can use Homebrew.
+
+```sh
+brew install ankane/brew/libtorch
+```
+
+Then install the gem (no need for `--with-torch-dir`).
+
+## 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.
+
+```sh
+brew upgrade ruby-build
+rbenv install [version]
+```
+
+## History
+
+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)
+- 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
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```
+
+Here are some good resources for contributors:
+
+- [PyTorch API](https://pytorch.org/docs/stable/torch.html)
+- [PyTorch C++ API](https://pytorch.org/cppdocs/)
+- [Tensor Creation API](https://pytorch.org/cppdocs/notes/tensor_creation.html)
+- [Using the PyTorch C++ Frontend](https://pytorch.org/tutorials/advanced/cpp_frontend.html)

data/ext/torch/ext.cpp

@@ -0,0 +1,546 @@
+#include <sstream>
+
+#include <torch/torch.h>
+
+#include <rice/Array.hpp>
+#include <rice/Class.hpp>
+#include <rice/Constructor.hpp>
+
+using namespace Rice;
+
+template<>
+inline
+long long from_ruby<long long>(Object x)
+{
+  return NUM2LL(x);
+}
+
+template<>
+inline
+Object to_ruby<long long>(long long const & x)
+{
+  return LL2NUM(x);
+}
+
+template<>
+inline
+unsigned long long from_ruby<unsigned long long>(Object x)
+{
+  return NUM2ULL(x);
+}
+
+template<>
+inline
+Object to_ruby<unsigned long long>(unsigned long long const & x)
+{
+  return ULL2NUM(x);
+}
+
+template<>
+inline
+short from_ruby<short>(Object x)
+{
+  return NUM2SHORT(x);
+}
+
+template<>
+inline
+Object to_ruby<short>(short const & x)
+{
+  return INT2NUM(x);
+}
+
+template<>
+inline
+unsigned short from_ruby<unsigned short>(Object x)
+{
+  return NUM2USHORT(x);
+}
+
+template<>
+inline
+Object to_ruby<unsigned short>(unsigned short const & x)
+{
+  return UINT2NUM(x);
+}
+
+// need to wrap torch::IntArrayRef() since
+// it doesn't own underlying data
+class IntArrayRef {
+  std::vector<int64_t> vec;
+  public:
+    IntArrayRef(Object o) {
+      Array a = Array(o);
+      for (size_t i = 0; i < a.size(); i++) {
+        vec.push_back(from_ruby<int64_t>(a[i]));
+      }
+    }
+    operator torch::IntArrayRef() {
+      return torch::IntArrayRef(vec);
+    }
+};
+
+template<>
+inline
+IntArrayRef from_ruby<IntArrayRef>(Object x)
+{
+  return IntArrayRef(x);
+}
+
+// for now
+typedef float Scalar;
+
+extern "C"
+void Init_ext()
+{
+  Module rb_mTorch = define_module("Torch")
+    .define_singleton_method(
+      "grad_enabled?",
+      *[]() {
+        return torch::GradMode::is_enabled();
+      })
+    .define_singleton_method(
+      "_set_grad_enabled",
+      *[](bool enabled) {
+        torch::GradMode::set_enabled(enabled);
+      })
+    .define_singleton_method(
+      "floating_point?",
+      *[](torch::Tensor& input) {
+        return torch::is_floating_point(input);
+      })
+    .define_singleton_method(
+      "manual_seed",
+      *[](uint64_t seed) {
+        return torch::manual_seed(seed);
+      })
+    // begin tensor creation
+    .define_singleton_method(
+      "_arange",
+      *[](Scalar start, Scalar end, Scalar step, const torch::TensorOptions &options) {
+        return torch::arange(start, end, step, options);
+      })
+    .define_singleton_method(
+      "_empty",
+      *[](IntArrayRef size, const torch::TensorOptions &options) {
+        return torch::empty(size, options);
+      })
+    .define_singleton_method(
+      "_eye",
+      *[](int64_t m, int64_t n, const torch::TensorOptions &options) {
+        return torch::eye(m, n, options);
+      })
+    .define_singleton_method(
+      "_full",
+      *[](IntArrayRef size, Scalar fill_value, const torch::TensorOptions& options) {
+        return torch::full(size, fill_value, options);
+      })
+    .define_singleton_method(
+      "_linspace",
+      *[](Scalar start, Scalar end, int64_t steps, const torch::TensorOptions& options) {
+        return torch::linspace(start, end, steps, options);
+      })
+    .define_singleton_method(
+      "_logspace",
+      *[](Scalar start, Scalar end, int64_t steps, double base, const torch::TensorOptions& options) {
+        return torch::logspace(start, end, steps, base, options);
+      })
+    .define_singleton_method(
+      "_ones",
+      *[](IntArrayRef size, const torch::TensorOptions &options) {
+        return torch::ones(size, options);
+      })
+    .define_singleton_method(
+      "_rand",
+      *[](IntArrayRef size, const torch::TensorOptions &options) {
+        return torch::rand(size, options);
+      })
+    .define_singleton_method(
+      "_randint",
+      *[](int64_t low, int64_t high, IntArrayRef size, const torch::TensorOptions &options) {
+        return torch::randint(low, high, size, options);
+      })
+    .define_singleton_method(
+      "_randn",
+      *[](IntArrayRef size, const torch::TensorOptions &options) {
+        return torch::randn(size, options);
+      })
+    .define_singleton_method(
+      "_randperm",
+      *[](int64_t n, const torch::TensorOptions &options) {
+        return torch::randperm(n, options);
+      })
+    .define_singleton_method(
+      "_zeros",
+      *[](IntArrayRef size, const torch::TensorOptions &options) {
+        return torch::zeros(size, options);
+      })
+    // begin operations
+    .define_singleton_method(
+      "_mean",
+      *[](torch::Tensor& input) {
+        return torch::mean(input);
+      })
+    .define_singleton_method(
+      "_mean_dim",
+      *[](torch::Tensor& input, int64_t dim, bool keepdim) {
+        return torch::mean(input, dim, keepdim);
+      })
+    .define_singleton_method(
+      "_sum",
+      *[](torch::Tensor& input) {
+        return torch::sum(input);
+      })
+    .define_singleton_method(
+      "_sum_dim",
+      *[](torch::Tensor& input, int64_t dim, bool keepdim) {
+        return torch::sum(input, dim, keepdim);
+      })
+    .define_singleton_method(
+      "_norm",
+      *[](torch::Tensor& input) {
+        return torch::norm(input);
+      })
+    .define_singleton_method(
+      "_min",
+      *[](torch::Tensor& input) {
+        return torch::min(input);
+      })
+    .define_singleton_method(
+      "_max",
+      *[](torch::Tensor& input) {
+        return torch::max(input);
+      })
+    .define_singleton_method(
+      "_exp",
+      *[](torch::Tensor& input) {
+        return torch::exp(input);
+      })
+    .define_singleton_method(
+      "_log",
+      *[](torch::Tensor& input) {
+        return torch::log(input);
+      })
+    .define_singleton_method(
+      "_unsqueeze",
+      *[](torch::Tensor& input, int64_t dim) {
+        return torch::unsqueeze(input, dim);
+      })
+    .define_singleton_method(
+      "_dot",
+      *[](torch::Tensor& input, torch::Tensor& tensor) {
+        return torch::dot(input, tensor);
+      })
+    .define_singleton_method(
+      "_matmul",
+      *[](torch::Tensor& input, torch::Tensor& other) {
+        return torch::matmul(input, other);
+      })
+    .define_singleton_method(
+      "_add",
+      *[](torch::Tensor& input, torch::Tensor& other) {
+        return torch::add(input, other);
+      })
+    .define_singleton_method(
+      "_add_scalar",
+      *[](torch::Tensor& input, float other) {
+        return torch::add(input, other);
+      })
+    .define_singleton_method(
+      "_add_out",
+      *[](torch::Tensor& out, torch::Tensor& input, torch::Tensor& other) {
+        return torch::add_out(out, input, other);
+      })
+    .define_singleton_method(
+      "_sub",
+      *[](torch::Tensor& input, torch::Tensor& other) {
+        return torch::sub(input, other);
+      })
+    .define_singleton_method(
+      "_sub_scalar",
+      *[](torch::Tensor& input, float other) {
+        return torch::sub(input, other);
+      })
+    .define_singleton_method(
+      "_mul",
+      *[](torch::Tensor& input, torch::Tensor& other) {
+        return torch::mul(input, other);
+      })
+    .define_singleton_method(
+      "_mul_scalar",
+      *[](torch::Tensor& input, float other) {
+        return torch::mul(input, other);
+      })
+    .define_singleton_method(
+      "_div",
+      *[](torch::Tensor& input, torch::Tensor& other) {
+        return torch::div(input, other);
+      })
+    .define_singleton_method(
+      "_div_scalar",
+      *[](torch::Tensor& input, float other) {
+        return torch::div(input, other);
+      })
+    .define_singleton_method(
+      "_remainder",
+      *[](torch::Tensor& input, torch::Tensor& other) {
+        return torch::remainder(input, other);
+      })
+    .define_singleton_method(
+      "_remainder_scalar",
+      *[](torch::Tensor& input, float other) {
+        return torch::remainder(input, other);
+      })
+    .define_singleton_method(
+      "_pow",
+      *[](torch::Tensor& input, Scalar exponent) {
+        return torch::pow(input, exponent);
+      })
+    .define_singleton_method(
+      "_neg",
+      *[](torch::Tensor& input) {
+        return torch::neg(input);
+      })
+    .define_singleton_method(
+      "relu",
+      *[](torch::Tensor& input) {
+        return torch::relu(input);
+      })
+    .define_singleton_method(
+      "conv2d",
+      *[](torch::Tensor& input, torch::Tensor& weight, torch::Tensor& bias) {
+        return torch::conv2d(input, weight, bias);
+      })
+    .define_singleton_method(
+      "linear",
+      *[](torch::Tensor& input, torch::Tensor& weight, torch::Tensor& bias) {
+        return torch::linear(input, weight, bias);
+      })
+    .define_singleton_method(
+      "max_pool2d",
+      *[](torch::Tensor& input, IntArrayRef kernel_size) {
+        return torch::max_pool2d(input, kernel_size);
+      })
+    .define_singleton_method(
+      "mse_loss",
+      *[](torch::Tensor& input, torch::Tensor& target, std::string reduction) {
+        auto red = reduction == "mean" ? Reduction::Mean : Reduction::Sum;
+        return torch::mse_loss(input, target, red);
+      })
+    .define_singleton_method(
+      "nll_loss",
+      *[](torch::Tensor& input, torch::Tensor& target) {
+        return torch::nll_loss(input, target);
+      })
+    .define_singleton_method(
+      "_tensor",
+      *[](Object o, IntArrayRef size, const torch::TensorOptions &options) {
+        Array a = Array(o);
+        std::vector<float> vec;
+        for (size_t i = 0; i < a.size(); i++) {
+          vec.push_back(from_ruby<float>(a[i]));
+        }
+        return torch::tensor(vec, options).reshape(size);
+      });
+
+  Class rb_cTensor = define_class_under<torch::Tensor>(rb_mTorch, "Tensor")
+    .define_method("cuda?", &torch::Tensor::is_cuda)
+    .define_method("distributed?", &torch::Tensor::is_distributed)
+    .define_method("complex?", &torch::Tensor::is_complex)
+    .define_method("floating_point?", &torch::Tensor::is_floating_point)
+    .define_method("signed?", &torch::Tensor::is_signed)
+    .define_method("sparse?", &torch::Tensor::is_sparse)
+    .define_method("quantized?", &torch::Tensor::is_quantized)
+    .define_method("dim", &torch::Tensor::dim)
+    .define_method("numel", &torch::Tensor::numel)
+    .define_method("element_size", &torch::Tensor::element_size)
+    .define_method("requires_grad", &torch::Tensor::requires_grad)
+    .define_method(
+      "zero!",
+      *[](torch::Tensor& self) {
+        return self.zero_();
+      })
+    .define_method(
+      "detach!",
+      *[](torch::Tensor& self) {
+        return self.detach_();
+      })
+    .define_method(
+      "_access",
+      *[](torch::Tensor& self, int64_t index) {
+        return self[index];
+      })
+    .define_method(
+      "_requires_grad!",
+      *[](torch::Tensor& self, bool requires_grad) {
+        return self.set_requires_grad(requires_grad);
+      })
+    .define_method(
+      "backward",
+      *[](torch::Tensor& self) {
+        return self.backward();
+      })
+    .define_method(
+      "grad",
+      *[](torch::Tensor& self) {
+        return self.grad();
+      })
+    .define_method(
+      "_dtype",
+      *[](torch::Tensor& self) {
+        return (int) at::typeMetaToScalarType(self.dtype());
+      })
+    .define_method(
+      "_layout",
+      *[](torch::Tensor& self) {
+        std::stringstream s;
+        s << self.layout();
+        return s.str();
+      })
+    .define_method(
+      "device",
+      *[](torch::Tensor& self) {
+        std::stringstream s;
+        s << self.device();
+        return s.str();
+      })
+    .define_method(
+      "_view",
+      *[](torch::Tensor& self, IntArrayRef size) {
+        return self.view(size);
+      })
+    .define_method(
+      "add!",
+      *[](torch::Tensor& self, torch::Tensor& other) {
+        self.add_(other);
+      })
+    .define_method(
+      "sub!",
+      *[](torch::Tensor& self, torch::Tensor& other) {
+        self.sub_(other);
+      })
+    .define_method(
+      "mul!",
+      *[](torch::Tensor& self, torch::Tensor& other) {
+        self.mul_(other);
+      })
+    .define_method(
+      "div!",
+      *[](torch::Tensor& self, torch::Tensor& other) {
+        self.div_(other);
+      })
+    .define_method(
+      "log_softmax",
+      *[](torch::Tensor& self, int64_t dim) {
+        return self.log_softmax(dim);
+      })
+    .define_method(
+      "_data",
+      *[](torch::Tensor& self) {
+        Array a;
+        auto dtype = self.dtype();
+
+        // TODO DRY if someone knows C++
+        // TODO kByte (uint8), kChar (int8), kBool (bool)
+        if (dtype == torch::kShort) {
+          short* data = self.data_ptr<short>();
+          for (int i = 0; i < self.numel(); i++) {
+            a.push(data[i]);
+          }
+        } else if (dtype == torch::kInt) {
+          int* data = self.data_ptr<int>();
+          for (int i = 0; i < self.numel(); i++) {
+            a.push(data[i]);
+          }
+        } else if (dtype == torch::kLong) {
+          long long* data = self.data_ptr<long long>();
+          for (int i = 0; i < self.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++) {
+            a.push(data[i]);
+          }
+        } else if (dtype == torch::kDouble) {
+          double* data = self.data_ptr<double>();
+          for (int i = 0; i < self.numel(); i++) {
+            a.push(data[i]);
+          }
+        } else {
+          throw "Unsupported type";
+        }
+        return a;
+      })
+    .define_method(
+      "_size",
+      *[](torch::Tensor& self, int i) {
+        return self.size(i);
+      })
+    .define_singleton_method(
+      "_make_subclass",
+      *[](torch::Tensor& rd, bool requires_grad) {
+        auto data = torch::autograd::as_variable_ref(rd).detach();
+        data.unsafeGetTensorImpl()->set_allow_tensor_metadata_change(true);
+        auto var = data.set_requires_grad(requires_grad);
+        return torch::autograd::Variable(std::move(var));
+      });
+
+  Class rb_cTensorOptions = define_class_under<torch::TensorOptions>(rb_mTorch, "TensorOptions")
+    .define_constructor(Constructor<torch::TensorOptions>())
+    .define_method(
+      "dtype",
+      *[](torch::TensorOptions& self, int dtype) {
+        return self.dtype((torch::ScalarType) dtype);
+      })
+    .define_method(
+      "layout",
+      *[](torch::TensorOptions& self, std::string layout) {
+        torch::Layout l;
+        if (layout == "strided") {
+          l = torch::kStrided;
+        } else {
+          throw "Unsupported layout";
+        }
+        return self.layout(l);
+      })
+    .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 "Unsupported device";
+        }
+        return self.device(d);
+      })
+    .define_method(
+      "requires_grad",
+      *[](torch::TensorOptions& self, bool requires_grad) {
+        return self.requires_grad(requires_grad);
+      });
+
+  Module rb_mNN = define_module_under(rb_mTorch, "NN");
+
+  Module rb_mInit = define_module_under(rb_mNN, "Init")
+    .define_singleton_method(
+      "kaiming_uniform_",
+      *[](torch::Tensor& input, double a) {
+        return torch::nn::init::kaiming_uniform_(input, a);
+      })
+    .define_singleton_method(
+      "uniform_",
+      *[](torch::Tensor& input, double to, double from) {
+        return torch::nn::init::uniform_(input, to, from);
+      });
+
+  Class rb_cParameter = define_class_under<torch::autograd::Variable, torch::Tensor>(rb_mNN, "Parameter")
+    .define_method(
+      "grad",
+      *[](torch::autograd::Variable& self) {
+        return self.grad();
+      });
+}