torch-rb 0.1.0

data/lib/torch/nn/functional.rb

@@ -0,0 +1,44 @@
+module Torch
+  module NN
+    class Functional
+      class << self
+        def relu(input)
+          Torch.relu(input)
+        end
+
+        def conv2d(input, weight, bias)
+          Torch.conv2d(input, weight, bias)
+        end
+
+        def max_pool2d(input, kernel_size)
+          kernel_size = [kernel_size, kernel_size] if kernel_size.is_a?(Integer)
+          Torch.max_pool2d(input, kernel_size)
+        end
+
+        def linear(input, weight, bias)
+          Torch.linear(input, weight, bias)
+        end
+
+        def mse_loss(input, target, reduction: "mean")
+          Torch.mse_loss(input, target, reduction)
+        end
+
+        def cross_entropy(input, target)
+          nll_loss(log_softmax(input, 1), target)
+        end
+
+        def nll_loss(input, target)
+          # TODO fix for non-1d
+          Torch.nll_loss(input, target)
+        end
+
+        def log_softmax(input, dim)
+          input.log_softmax(dim)
+        end
+      end
+    end
+
+    # shortcut
+    F = Functional
+  end
+end

data/lib/torch/nn/init.rb

@@ -0,0 +1,30 @@
+module Torch
+  module NN
+    module Init
+      class << self
+        def calculate_fan_in_and_fan_out(tensor)
+          dimensions = tensor.dim
+          if dimensions < 2
+            raise Error, "Fan in and fan out can not be computed for tensor with fewer than 2 dimensions"
+          end
+
+          if dimensions == 2
+            fan_in = tensor.size(1)
+            fan_out = tensor.size(0)
+          else
+            num_input_fmaps = tensor.size(1)
+            num_output_fmaps = tensor.size(0)
+            receptive_field_size = 1
+            if tensor.dim > 2
+              receptive_field_size = tensor[0][0].numel
+            end
+            fan_in = num_input_fmaps * receptive_field_size
+            fan_out = num_output_fmaps * receptive_field_size
+          end
+
+          [fan_in, fan_out]
+        end
+      end
+    end
+  end
+end

data/lib/torch/nn/linear.rb

@@ -0,0 +1,36 @@
+module Torch
+  module NN
+    class Linear < Module
+      attr_reader :bias, :weight
+
+      def initialize(in_features, out_features, bias: true)
+        @in_features = in_features
+        @out_features = out_features
+
+        @weight = Parameter.new(Tensor.new(out_features, in_features))
+        if bias
+          @bias = Parameter.new(Tensor.new(out_features))
+        end
+
+        reset_parameters
+      end
+
+      def call(input)
+        F.linear(input, @weight, @bias)
+      end
+
+      def reset_parameters
+        Init.kaiming_uniform_(@weight, Math.sqrt(5))
+        if @bias
+          fan_in, _ = Init.calculate_fan_in_and_fan_out(@weight)
+          bound = 1 / Math.sqrt(fan_in)
+          Init.uniform_(@bias, -bound, bound)
+        end
+      end
+
+      def inspect
+        "Linear(in_features: #{@in_features.inspect}, out_features: #{@out_features.inspect}, bias: #{(!@bias.nil?).inspect})"
+      end
+    end
+  end
+end

data/lib/torch/nn/module.rb

@@ -0,0 +1,56 @@
+module Torch
+  module NN
+    class Module
+      def inspect
+        str = String.new
+        str << "#{self.class.name}(\n"
+        modules.each do |name, mod|
+          str << "  (#{name}): #{mod.inspect}\n"
+        end
+        str << ")"
+      end
+
+      def call(*input)
+        forward(*input)
+      end
+
+      def parameters
+        params = []
+        instance_variables.each do |name|
+          param = instance_variable_get(name)
+          params << param if param.is_a?(Parameter)
+        end
+        params + modules.flat_map { |_, mod| mod.parameters }
+      end
+
+      def zero_grad
+        parameters.each do |param|
+          if param.grad
+            raise Error, "Not supported yet"
+            param.grad.detach!
+            param.grad.zero!
+          end
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        modules[method.to_s] || super
+      end
+
+      def respond_to?(method, include_private = false)
+        modules.key?(method.to_s) || super
+      end
+
+      private
+
+      def modules
+        modules = {}
+        instance_variables.each do |name|
+          mod = instance_variable_get(name)
+          modules[name[1..-1]] = mod if mod.is_a?(Module)
+        end
+        modules
+      end
+    end
+  end
+end

data/lib/torch/nn/mse_loss.rb

@@ -0,0 +1,13 @@
+module Torch
+  module NN
+    class MSELoss < Module
+      def initialize(reduction: "mean")
+        @reduction = reduction
+      end
+
+      def forward(input, target)
+        F.mse_loss(input, target, reduction: @reduction)
+      end
+    end
+  end
+end

data/lib/torch/nn/parameter.rb

@@ -0,0 +1,10 @@
+module Torch
+  module NN
+    class Parameter < Tensor
+      def self.new(data = nil, requires_grad: true)
+        data = Tensor.new unless data
+        Tensor._make_subclass(data, requires_grad)
+      end
+    end
+  end
+end

data/lib/torch/nn/relu.rb

@@ -0,0 +1,13 @@
+module Torch
+  module NN
+    class ReLU < Module
+      def initialize #(inplace: false)
+        # @inplace = inplace
+      end
+
+      def forward(input)
+        F.relu(input) #, inplace: @inplace)
+      end
+    end
+  end
+end

data/lib/torch/nn/sequential.rb

@@ -0,0 +1,29 @@
+module Torch
+  module NN
+    class Sequential < Module
+      def initialize(*args)
+        @modules = {}
+        # TODO support hash arg (named modules)
+        args.each_with_index do |mod, idx|
+          add_module(idx.to_s, mod)
+        end
+      end
+
+      def add_module(name, mod)
+        # TODO add checks
+        @modules[name] = mod
+      end
+
+      def forward(input)
+        @modules.values.each do |mod|
+          input = mod.call(input)
+        end
+        input
+      end
+
+      def parameters
+        @modules.flat_map { |_, mod| mod.parameters }
+      end
+    end
+  end
+end

data/lib/torch/tensor.rb

@@ -0,0 +1,143 @@
+module Torch
+  class Tensor
+    include Comparable
+    include Inspector
+
+    alias_method :requires_grad?, :requires_grad
+
+    def self.new(*size)
+      if size.first.is_a?(Tensor)
+        size.first
+      else
+        Torch.rand(*size)
+      end
+    end
+
+    def dtype
+      dtype = ENUM_TO_DTYPE[_dtype]
+      raise Error, "Unknown type: #{_dtype}" unless dtype
+      dtype
+    end
+
+    def layout
+      _layout.downcase.to_sym
+    end
+
+    def to_s
+      inspect
+    end
+
+    def to_a
+      reshape(_data, shape)
+    end
+
+    def size(dim = nil)
+      if dim
+        _size(dim)
+      else
+        shape
+      end
+    end
+
+    def shape
+      dim.times.map { |i| size(i) }
+    end
+
+    def view(*size)
+      _view(size)
+    end
+
+    def item
+      if numel != 1
+        raise Error, "only one element tensors can be converted to Ruby scalars"
+      end
+      _data.first
+    end
+
+    def data
+      Torch.tensor(to_a)
+    end
+
+    # TODO read directly from memory
+    def numo
+      raise Error, "Numo not found" unless defined?(Numo::NArray)
+      cls = Torch._dtype_to_numo[dtype]
+      raise Error, "Cannot convert #{dtype} to Numo" unless cls
+      cls.cast(_data).reshape(*shape)
+    end
+
+    def new_ones(*size, **options)
+      Torch.ones_like(Torch.empty(*size), **options)
+    end
+
+    def requires_grad!(requires_grad = true)
+      _requires_grad!(requires_grad)
+    end
+
+    # operations
+    %w(add sub mul div remainder pow neg sum mean num norm min max dot matmul exp log unsqueeze).each do |op|
+      define_method(op) do |*args, **options, &block|
+        if options.any?
+          Torch.send(op, self, *args, **options, &block)
+        else
+          Torch.send(op, self, *args, &block)
+        end
+      end
+    end
+
+    def +(other)
+      add(other)
+    end
+
+    def -(other)
+      sub(other)
+    end
+
+    def *(other)
+      mul(other)
+    end
+
+    def /(other)
+      div(other)
+    end
+
+    def %(other)
+      remainder(other)
+    end
+
+    def **(other)
+      pow(other)
+    end
+
+    def -@
+      neg
+    end
+
+    def <=>(other)
+      item <=> other
+    end
+
+    # TODO use accessor C++ method
+    def [](index, *args)
+      v = _access(index)
+      args.each do |i|
+        v = v._access(i)
+      end
+      v
+    end
+
+    private
+
+    def reshape(arr, dims)
+      if dims.empty?
+        arr
+      else
+        arr = arr.flatten
+        dims[1..-1].reverse.each do |dim|
+          arr = arr.each_slice(dim)
+        end
+        arr.to_a
+      end
+    end
+  end
+end

data/lib/torch/utils/data/data_loader.rb

@@ -0,0 +1,12 @@
+module Torch
+  module Utils
+    module Data
+      class DataLoader
+        def initialize(dataset, batch_size: 1)
+          @dataset = dataset
+          @batch_size = batch_size
+        end
+      end
+    end
+  end
+end

data/lib/torch/utils/data/tensor_dataset.rb

@@ -0,0 +1,15 @@
+module Torch
+  module Utils
+    module Data
+      class TensorDataset
+        def initialize(*tensors)
+          @tensors = tensors
+        end
+
+        def [](index)
+          tensors.map { |t| t[index] }
+        end
+      end
+    end
+  end
+end

data/lib/torch/version.rb

@@ -0,0 +1,3 @@
+module Torch
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: torch-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: andrew@chartkick.com
+executables: []
+extensions:
+- ext/torch/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- ext/torch/ext.cpp
+- ext/torch/extconf.rb
+- lib/torch-rb.rb
+- lib/torch.rb
+- lib/torch/ext.bundle
+- lib/torch/inspector.rb
+- lib/torch/nn/conv2d.rb
+- lib/torch/nn/functional.rb
+- lib/torch/nn/init.rb
+- lib/torch/nn/linear.rb
+- lib/torch/nn/module.rb
+- lib/torch/nn/mse_loss.rb
+- lib/torch/nn/parameter.rb
+- lib/torch/nn/relu.rb
+- lib/torch/nn/sequential.rb
+- lib/torch/tensor.rb
+- lib/torch/utils/data/data_loader.rb
+- lib/torch/utils/data/tensor_dataset.rb
+- lib/torch/version.rb
+homepage: https://github.com/ankane/torch-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Deep learning for Ruby, powered by LibTorch
+test_files: []