torch-rb 0.1.2 → 0.1.7

data/lib/torch/optim/sgd.rb

@@ -1,27 +1,59 @@
+# ported from https://github.com/pytorch/pytorch/blob/master/torch/optim/sgd.py
 module Torch
   module Optim
     class SGD < Optimizer
-      def initialize(params, lr:)
-        @params = params
-        @lr = lr
-      end
+      def initialize(params, lr:, momentum: 0, dampening: 0, weight_decay: 0, nesterov: false)
+        raise ArgumentError, "Invalid learning rate: #{lr}" if lr < 0.0
+        raise ArgumentError, "Invalid momentum value: #{momentum}" if momentum < 0.0
+        raise ArgumentError, "Invalid weight_decay value: #{weight_decay}" if weight_decay < 0.0
 
-      def zero_grad
-        @params.each do |param|
-          if param.grad
-            param.grad.detach!
-            param.grad.zero!
-          end
+        defaults = {lr: lr, momentum: momentum, dampening: dampening, weight_decay: weight_decay, nesterov: nesterov}
+
+        if nesterov && (momentum <= 0 || dampening != 0)
+          raise ArgumentError, "Nesterov momentum requires a momentum and zero dampening"
         end
+
+        super(params, defaults)
       end
 
-      def step
-        @params.each do |param|
-          next unless param.grad
-          d_p = param.grad.data
-          # same as param.data.add!(-@lr, d_p)
-          param.data.sub!(d_p * @lr)
+      def step(closure = nil)
+        loss = nil
+        if closure
+          loss = closure.call
+        end
+
+        @param_groups.each do |group|
+          weight_decay = group[:weight_decay]
+          momentum = group[:momentum]
+          dampening = group[:dampening]
+          nesterov = group[:nesterov]
+
+          group[:params].each do |p|
+            next unless p.grad
+            d_p = p.grad.data
+            if weight_decay != 0
+              d_p.add!(weight_decay, p.data)
+            end
+            if momentum != 0
+              param_state = @state[p]
+              if !param_state.key(:momentum_buffer)
+                buf = param_state[:momentum_buffer] = Torch.clone(d_p).detach
+              else
+                buf = param_state[:momentum_buffer]
+                buf.mul!(momentum).add!(1 - dampening, d_p)
+              end
+              if nesterov
+                d_p = d_p.add(momentum, buf)
+              else
+                d_p = buf
+              end
+            end
+
+            p.data.add!(-group[:lr], d_p)
+          end
         end
+
+        loss
       end
     end
   end

data/lib/torch/random.rb

@@ -0,0 +1,10 @@
+module Torch
+  module Random
+    class << self
+      # not available through LibTorch
+      def initial_seed
+        raise NotImplementedYet
+      end
+    end
+  end
+end

data/lib/torch/tensor.rb

@@ -5,12 +5,8 @@ module Torch
 
     alias_method :requires_grad?, :requires_grad
 
-    def self.new(*size)
-      if size.first.is_a?(Tensor)
-        size.first
-      else
-        Torch.rand(*size)
-      end
+    def self.new(*args)
+      FloatTensor.new(*args)
     end
 
     def dtype
@@ -28,12 +24,18 @@ module Torch
     end
 
     def to_a
-      reshape_arr(_data, shape)
+      reshape_arr(_flat_data, shape)
+    end
+
+    # TODO support dtype
+    def to(device, non_blocking: false, copy: false)
+      device = Device.new(device) if device.is_a?(String)
+      _to(device, _dtype, non_blocking, copy)
     end
 
     def size(dim = nil)
       if dim
-        _size(dim)
+        _size_int(dim)
       else
         shape
       end
@@ -43,31 +45,32 @@ module Torch
       dim.times.map { |i| size(i) }
     end
 
-    def view(*size)
-      _view(size)
+    # mirror Python len()
+    def length
+      size(0)
     end
 
     def item
       if numel != 1
         raise Error, "only one element tensors can be converted to Ruby scalars"
       end
-      _data.first
+      _flat_data.first
+    end
+
+    # unsure if this is correct
+    def new
+      Torch.empty(0, dtype: dtype)
     end
 
     def backward(gradient = nil)
-      if gradient
-        _backward_gradient(gradient)
-      else
-        _backward
-      end
+      _backward(gradient)
     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)
+      cls.cast(_flat_data).reshape(*shape)
     end
 
     def new_ones(*size, **options)
@@ -84,14 +87,23 @@ module Torch
       _type(enum)
     end
 
-    # operations
-    %w(add sub mul div remainder pow neg sum mean num norm min max dot matmul exp log unsqueeze reshape argmax eq).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
+    def reshape(*size)
+      # Python doesn't check if size == 1, just ignores later arguments
+      size = size.first if size.size == 1 && size.first.is_a?(Array)
+      _reshape(size)
+    end
+
+    def view(*size)
+      size = size.first if size.size == 1 && size.first.is_a?(Array)
+      _view(size)
+    end
+
+    # value and other are swapped for some methods
+    def add!(value = 1, other)
+      if other.is_a?(Numeric)
+        _add__scalar(other, value)
+      else
+        _add__tensor(other, value)
       end
     end
 
@@ -127,26 +139,55 @@ module Torch
       item <=> other
     end
 
+    # based on python_variable_indexing.cpp
     def [](*indexes)
       result = self
       dim = 0
-      indexes.each_with_index do |index|
+      indexes.each do |index|
         if index.is_a?(Numeric)
-          result = result._select(dim, index)
+          result = result._select_int(dim, index)
         elsif index.is_a?(Range)
           finish = index.end
           finish += 1 unless index.exclude_end?
-          result = result._slice(dim, index.begin, finish, 1)
+          result = result._slice_tensor(dim, index.begin, finish, 1)
+          dim += 1
+        elsif index.nil?
+          result = result.unsqueeze(dim)
           dim += 1
+        elsif index == true
+          result = result.unsqueeze(dim)
+          # TODO handle false
         else
-          raise Error, "Unsupported index type"
+          raise Error, "Unsupported index type: #{index.class.name}"
         end
       end
       result
     end
 
+    # TODO
+    # based on python_variable_indexing.cpp
+    def []=(index, value)
+      raise ArgumentError, "Tensor does not support deleting items" if value.nil?
+
+      value = Torch.tensor(value) unless value.is_a?(Tensor)
+
+      if index.is_a?(Numeric)
+        copy_to(_select_int(0, index), value)
+      elsif index.is_a?(Range)
+        finish = index.end
+        finish += 1 unless index.exclude_end?
+        copy_to(_slice_tensor(0, index.begin, finish, 1), value)
+      else
+        raise Error, "Unsupported index type: #{index.class.name}"
+      end
+    end
+
     private
 
+    def copy_to(dst, src)
+      dst.copy!(src)
+    end
+
     def reshape_arr(arr, dims)
       if dims.empty?
         arr

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

@@ -2,19 +2,25 @@ module Torch
   module Utils
     module Data
       class DataLoader
+        include Enumerable
+
+        attr_reader :dataset
+
         def initialize(dataset, batch_size: 1)
           @dataset = dataset
           @batch_size = batch_size
         end
 
         def each
-          size = @dataset.size
-          start_index = 0
-          while start_index < size
+          size.times do |i|
+            start_index = i * @batch_size
             yield @dataset[start_index...(start_index + @batch_size)]
-            start_index += @batch_size
           end
         end
+
+        def size
+          (@dataset.size / @batch_size.to_f).ceil
+        end
       end
     end
   end

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

@@ -3,6 +3,9 @@ module Torch
     module Data
       class TensorDataset
         def initialize(*tensors)
+          unless tensors.all? { |t| t.size(0) == tensors[0].size(0) }
+            raise Error, "Tensors must all have same dim 0 size"
+          end
           @tensors = tensors
         end
 

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.1.2"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.7
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-27 00:00:00.000000000 Z
+date: 2020-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -106,28 +106,145 @@ files:
 - README.md
 - ext/torch/ext.cpp
 - ext/torch/extconf.rb
+- ext/torch/nn_functions.cpp
+- ext/torch/nn_functions.hpp
+- ext/torch/templates.cpp
+- ext/torch/templates.hpp
+- ext/torch/tensor_functions.cpp
+- ext/torch/tensor_functions.hpp
+- ext/torch/torch_functions.cpp
+- ext/torch/torch_functions.hpp
 - lib/torch-rb.rb
 - lib/torch.rb
 - lib/torch/ext.bundle
 - lib/torch/inspector.rb
+- lib/torch/native/dispatcher.rb
+- lib/torch/native/function.rb
+- lib/torch/native/generator.rb
+- lib/torch/native/native_functions.yaml
+- lib/torch/native/parser.rb
+- lib/torch/nn/alpha_dropout.rb
+- lib/torch/nn/avg_pool1d.rb
+- lib/torch/nn/avg_pool2d.rb
+- lib/torch/nn/avg_pool3d.rb
+- lib/torch/nn/avg_poolnd.rb
+- lib/torch/nn/batch_norm.rb
+- lib/torch/nn/batch_norm1d.rb
+- lib/torch/nn/batch_norm2d.rb
+- lib/torch/nn/batch_norm3d.rb
+- lib/torch/nn/bce_loss.rb
+- lib/torch/nn/bce_with_logits_loss.rb
+- lib/torch/nn/bilinear.rb
+- lib/torch/nn/constant_pad1d.rb
+- lib/torch/nn/constant_pad2d.rb
+- lib/torch/nn/constant_pad3d.rb
+- lib/torch/nn/constant_padnd.rb
+- lib/torch/nn/conv1d.rb
 - lib/torch/nn/conv2d.rb
+- lib/torch/nn/conv3d.rb
+- lib/torch/nn/convnd.rb
+- lib/torch/nn/cosine_embedding_loss.rb
+- lib/torch/nn/cosine_similarity.rb
+- lib/torch/nn/cross_entropy_loss.rb
+- lib/torch/nn/ctc_loss.rb
+- lib/torch/nn/dropout.rb
+- lib/torch/nn/dropout2d.rb
+- lib/torch/nn/dropout3d.rb
+- lib/torch/nn/dropoutnd.rb
+- lib/torch/nn/embedding.rb
+- lib/torch/nn/embedding_bag.rb
+- lib/torch/nn/feature_alpha_dropout.rb
+- lib/torch/nn/fold.rb
 - lib/torch/nn/functional.rb
+- lib/torch/nn/group_norm.rb
+- lib/torch/nn/gru.rb
+- lib/torch/nn/hardshrink.rb
+- lib/torch/nn/hinge_embedding_loss.rb
+- lib/torch/nn/identity.rb
 - lib/torch/nn/init.rb
+- lib/torch/nn/instance_norm.rb
+- lib/torch/nn/instance_norm1d.rb
+- lib/torch/nn/instance_norm2d.rb
+- lib/torch/nn/instance_norm3d.rb
+- lib/torch/nn/kl_div_loss.rb
+- lib/torch/nn/l1_loss.rb
+- lib/torch/nn/layer_norm.rb
+- lib/torch/nn/leaky_relu.rb
 - lib/torch/nn/linear.rb
+- lib/torch/nn/local_response_norm.rb
+- lib/torch/nn/log_sigmoid.rb
+- lib/torch/nn/log_softmax.rb
+- lib/torch/nn/loss.rb
+- lib/torch/nn/lp_pool1d.rb
+- lib/torch/nn/lp_pool2d.rb
+- lib/torch/nn/lp_poolnd.rb
+- lib/torch/nn/lstm.rb
+- lib/torch/nn/margin_ranking_loss.rb
+- lib/torch/nn/max_pool1d.rb
+- lib/torch/nn/max_pool2d.rb
+- lib/torch/nn/max_pool3d.rb
+- lib/torch/nn/max_poolnd.rb
+- lib/torch/nn/max_unpool1d.rb
+- lib/torch/nn/max_unpool2d.rb
+- lib/torch/nn/max_unpool3d.rb
+- lib/torch/nn/max_unpoolnd.rb
 - lib/torch/nn/module.rb
 - lib/torch/nn/mse_loss.rb
+- lib/torch/nn/multi_label_margin_loss.rb
+- lib/torch/nn/multi_label_soft_margin_loss.rb
+- lib/torch/nn/multi_margin_loss.rb
+- lib/torch/nn/nll_loss.rb
+- lib/torch/nn/pairwise_distance.rb
 - lib/torch/nn/parameter.rb
+- lib/torch/nn/poisson_nll_loss.rb
+- lib/torch/nn/prelu.rb
+- lib/torch/nn/reflection_pad1d.rb
+- lib/torch/nn/reflection_pad2d.rb
+- lib/torch/nn/reflection_padnd.rb
 - lib/torch/nn/relu.rb
+- lib/torch/nn/replication_pad1d.rb
+- lib/torch/nn/replication_pad2d.rb
+- lib/torch/nn/replication_pad3d.rb
+- lib/torch/nn/replication_padnd.rb
+- lib/torch/nn/rnn.rb
+- lib/torch/nn/rnn_base.rb
 - lib/torch/nn/sequential.rb
+- lib/torch/nn/sigmoid.rb
+- lib/torch/nn/smooth_l1_loss.rb
+- lib/torch/nn/soft_margin_loss.rb
+- lib/torch/nn/softmax.rb
+- lib/torch/nn/softmax2d.rb
+- lib/torch/nn/softmin.rb
+- lib/torch/nn/softplus.rb
+- lib/torch/nn/softshrink.rb
+- lib/torch/nn/softsign.rb
+- lib/torch/nn/tanh.rb
+- lib/torch/nn/tanhshrink.rb
+- lib/torch/nn/triplet_margin_loss.rb
+- lib/torch/nn/unfold.rb
+- lib/torch/nn/utils.rb
+- lib/torch/nn/weighted_loss.rb
+- lib/torch/nn/zero_pad2d.rb
+- lib/torch/optim/adadelta.rb
+- lib/torch/optim/adagrad.rb
+- lib/torch/optim/adam.rb
+- lib/torch/optim/adamax.rb
+- lib/torch/optim/adamw.rb
+- lib/torch/optim/asgd.rb
+- lib/torch/optim/lr_scheduler/lr_scheduler.rb
+- lib/torch/optim/lr_scheduler/step_lr.rb
 - lib/torch/optim/optimizer.rb
+- lib/torch/optim/rmsprop.rb
+- lib/torch/optim/rprop.rb
 - lib/torch/optim/sgd.rb
+- lib/torch/random.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
+- BSD-3-Clause
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -144,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Deep learning for Ruby, powered by LibTorch