torch-rb 0.1.8 → 0.2.0

data/lib/torch/native/parser.rb

@@ -99,6 +99,8 @@ module Torch
                 v.nil?
               when "bool"
                 v == true || v == false
+              when "str"
+                v.is_a?(String)
               else
                 raise Error, "Unknown argument type: #{arg_types[k]}. Please report a bug with #{@name}."
               end

data/lib/torch/nn/adaptive_avg_pool1d.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class AdaptiveAvgPool1d < AdaptiveAvgPoolNd
+      def forward(input)
+        F.adaptive_avg_pool1d(input, @output_size)
+      end
+    end
+  end
+end

data/lib/torch/nn/adaptive_avg_pool2d.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class AdaptiveAvgPool2d < AdaptiveAvgPoolNd
+      def forward(input)
+        F.adaptive_avg_pool2d(input, @output_size)
+      end
+    end
+  end
+end

data/lib/torch/nn/adaptive_avg_pool3d.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class AdaptiveAvgPool3d < AdaptiveAvgPoolNd
+      def forward(input)
+        F.adaptive_avg_pool3d(input, @output_size)
+      end
+    end
+  end
+end

data/lib/torch/nn/adaptive_avg_poolnd.rb

@@ -0,0 +1,14 @@
+module Torch
+  module NN
+    class AdaptiveAvgPoolNd < Module
+      def initialize(output_size)
+        super()
+        @output_size = output_size
+      end
+
+      def extra_inspect
+        format("output_size: %s", @output_size)
+      end
+    end
+  end
+end

data/lib/torch/nn/adaptive_max_pool1d.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class AdaptiveMaxPool1d < AdaptiveMaxPoolNd
+      def forward(input)
+        F.adaptive_max_pool1d(input, @output_size) #, @return_indices)
+      end
+    end
+  end
+end

data/lib/torch/nn/adaptive_max_pool2d.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class AdaptiveMaxPool2d < AdaptiveMaxPoolNd
+      def forward(input)
+        F.adaptive_max_pool2d(input, @output_size) #, @return_indices)
+      end
+    end
+  end
+end

data/lib/torch/nn/adaptive_max_pool3d.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class AdaptiveMaxPool3d < AdaptiveMaxPoolNd
+      def forward(input)
+        F.adaptive_max_pool3d(input, @output_size) #, @return_indices)
+      end
+    end
+  end
+end

data/lib/torch/nn/adaptive_max_poolnd.rb

@@ -0,0 +1,15 @@
+module Torch
+  module NN
+    class AdaptiveMaxPoolNd < Module
+      def initialize(output_size) #, return_indices: false)
+        super()
+        @output_size = output_size
+        # @return_indices = return_indices
+      end
+
+      def extra_inspect
+        format("output_size: %s", @output_size)
+      end
+    end
+  end
+end

data/lib/torch/nn/functional.rb

@@ -99,6 +99,34 @@ module Torch
           NN.avg_pool3d(*args, **options)
         end
 
+        def adaptive_max_pool1d(*args, **options)
+          Torch.adaptive_max_pool1d(*args, **options)
+        end
+
+        def adaptive_max_pool2d(input, output_size)
+          output_size = list_with_default(output_size, input.size)
+          NN.adaptive_max_pool2d(input, output_size)
+        end
+
+        def adaptive_max_pool3d(input, output_size)
+          output_size = list_with_default(output_size, input.size)
+          NN.adaptive_max_pool3d(input, output_size)
+        end
+
+        def adaptive_avg_pool1d(*args, **options)
+          Torch.adaptive_avg_pool1d(*args, **options)
+        end
+
+        def adaptive_avg_pool2d(input, output_size)
+          output_size = list_with_default(output_size, input.size)
+          NN.adaptive_avg_pool2d(input, output_size)
+        end
+
+        def adaptive_avg_pool3d(input, output_size)
+          output_size = list_with_default(output_size, input.size)
+          NN.adaptive_avg_pool3d(input, output_size)
+        end
+
         # padding layers
 
         def pad(input, pad, mode: "constant", value: 0)
@@ -369,7 +397,7 @@ module Torch
         end
 
         def cosine_embedding_loss(input1, input2, target, margin: 0, reduction: "mean")
-          raise NotImplementedYet
+          Torch.cosine_embedding_loss(input1, input2, target, margin, reduction)
         end
 
         def cross_entropy(input, target, weight: nil, ignore_index: -100, reduction: "mean")
@@ -394,7 +422,7 @@ module Torch
         end
 
         def margin_ranking_loss(input1, input2, target, margin: 0, reduction: "mean")
-          raise NotImplementedYet
+          Torch.margin_ranking_loss(input1, input2, target, margin, reduction)
         end
 
         def mse_loss(input, target, reduction: "mean")
@@ -438,6 +466,16 @@ module Torch
         def softmax_dim(ndim)
           ndim == 0 || ndim == 1 || ndim == 3 ? 0 : 1
         end
+
+        def list_with_default(out_size, defaults)
+          if out_size.is_a?(Integer)
+            out_size
+          elsif defaults.length < out_size.length
+            raise ArgumentError, "Input dimension should be at least #{out_size.length + 1}"
+          else
+            out_size.zip(defaults.last(out_size.length)).map { |v, d| v || d }
+          end
+        end
       end
     end
 

data/lib/torch/nn/module.rb

@@ -34,6 +34,27 @@ module Torch
         children.each do |mod|
           mod._apply(fn)
         end
+
+        instance_variables.each do |key|
+          param = instance_variable_get(key)
+          if param.is_a?(Parameter)
+            param_applied = nil
+            Torch.no_grad do
+              param_applied = fn.call(param)
+            end
+            # TODO should_use_set_data
+            instance_variable_set(key, Parameter.new(param_applied, requires_grad: param.requires_grad))
+
+            if param.grad
+              grad_applied = nil
+              Torch.no_grad do
+                grad_applied = fn.call(param.grad)
+              end
+              # TODO should_use_set_data
+              instance_variable_get(key).grad = grad_applied.requires_grad!(param.grad.requires_grad)
+            end
+          end
+        end
         # TODO apply to more objects
         self
       end
@@ -111,7 +132,7 @@ module Torch
           params[[prefix, name[1..-1]].join] = param if param.is_a?(Parameter)
         end
         @parameters.each do |name, param|
-          params[[prefix, name].join] = param
+          params[[prefix, name].join] = param if param
         end
         params
       end

data/lib/torch/optim/lr_scheduler/cosine_annealing_lr.rb

@@ -0,0 +1,29 @@
+module Torch
+  module Optim
+    module LRScheduler
+      class CosineAnnealingLR < LRScheduler
+        def initialize(optimizer, t_max, eta_min: 0, last_epoch: -1)
+          @t_max = t_max
+          @eta_min = eta_min
+          super(optimizer, last_epoch)
+        end
+
+        def get_lr
+          if @last_epoch == 0
+            @base_lrs
+          elsif (@last_epoch - 1 - @t_max) % (2 * @t_max) == 0
+            @base_lrs.zip(@optimizer.param_groups).map do |base_lr, group|
+              group[:lr] + (base_lr - @eta_min) * (1 - Math.cos(Math::PI / @t_max)) / 2
+            end
+          else
+            @optimizer.param_groups.map do |group|
+              (1 + Math.cos(Math::PI * @last_epoch / @t_max)) /
+              (1 + Math.cos(Math::PI * (@last_epoch - 1) / @t_max)) *
+              (group[:lr] - @eta_min) + @eta_min
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/torch/optim/lr_scheduler/exponential_lr.rb

@@ -0,0 +1,22 @@
+module Torch
+  module Optim
+    module LRScheduler
+      class ExponentialLR < LRScheduler
+        def initialize(optimizer, gamma, last_epoch: -1)
+          @gamma = gamma
+          super(optimizer, last_epoch)
+        end
+
+        def get_lr
+          if @last_epoch == 0
+            @base_lrs
+          else
+            @optimizer.param_groups.map do |group|
+              group[:lr] * @gamma
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/torch/optim/lr_scheduler/lambda_lr.rb

@@ -0,0 +1,28 @@
+module Torch
+  module Optim
+    module LRScheduler
+      class LambdaLR < LRScheduler
+        def initialize(optimizer, lr_lambda, last_epoch: -1)
+          @optimizer = optimizer
+
+          if !lr_lambda.is_a?(Array)
+            @lr_lambdas = [lr_lambda] * optimizer.param_groups.length
+          else
+            if lr_lambda.length != optimizer.param_groups.length
+              raise ArgumentError, "Expected #{optimizer.param_groups.length}, but got #{lr_lambda.length}"
+            end
+            @lr_lambdas = lr_lambda
+          end
+          @last_epoch = last_epoch
+          super(optimizer, last_epoch)
+        end
+
+        def get_lr
+          @lr_lambdas.zip(@base_lrs).map do |lmbda, base_lr|
+            base_lr * lmbda.call(@last_epoch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/torch/optim/lr_scheduler/multi_step_lr.rb

@@ -0,0 +1,23 @@
+module Torch
+  module Optim
+    module LRScheduler
+      class MultiStepLR < LRScheduler
+        def initialize(optimizer, milestones, gamma: 0.1, last_epoch: -1)
+          @milestones = milestones.map.with_index.map { |v, i| [v, i + 1] }.to_h
+          @gamma = gamma
+          super(optimizer, last_epoch)
+        end
+
+        def get_lr
+          if !@milestones.include?(@last_epoch)
+            @optimizer.param_groups.map { |group| group[:lr] }
+          else
+            @optimizer.param_groups.map do |group|
+              group[:lr] * @gamma ** @milestones[@last_epoch]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/torch/optim/lr_scheduler/multiplicative_lr.rb

@@ -0,0 +1,32 @@
+module Torch
+  module Optim
+    module LRScheduler
+      class MultiplicativeLR < LRScheduler
+        def initialize(optimizer, lr_lambda, last_epoch: -1)
+          @optimizer = optimizer
+
+          if !lr_lambda.is_a?(Array)
+            @lr_lambdas = [lr_lambda] * optimizer.param_groups.length
+          else
+            if lr_lambda.length != optimizer.param_groups.length
+              raise ArgumentError, "Expected #{optimizer.param_groups.length}, but got #{lr_lambda.length}"
+            end
+            @lr_lambdas = lr_lambda
+          end
+          @last_epoch = last_epoch
+          super(optimizer, last_epoch)
+        end
+
+        def get_lr
+          if @last_epoch > 0
+            @lr_lambdas.zip(@optimizer.param_groups).map do |lmbda, group|
+              group[:lr] * lmbda.call(@last_epoch)
+            end
+          else
+            @base_lrs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/torch/tensor.rb

@@ -33,6 +33,10 @@ module Torch
       _to(device, _dtype, non_blocking, copy)
     end
 
+    def cpu
+      to("cpu")
+    end
+
     def size(dim = nil)
       if dim
         _size_int(dim)
@@ -182,6 +186,10 @@ module Torch
       end
     end
 
+    def random!(from = 0, to)
+      _random__from_to(from, to)
+    end
+
     private
 
     def copy_to(dst, src)

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.1.8"
+  VERSION = "0.2.0"
 end

data/lib/torch.rb

@@ -25,7 +25,12 @@ require "torch/optim/sgd"
 
 # optim lr_scheduler
 require "torch/optim/lr_scheduler/lr_scheduler"
+require "torch/optim/lr_scheduler/lambda_lr"
+require "torch/optim/lr_scheduler/multiplicative_lr"
 require "torch/optim/lr_scheduler/step_lr"
+require "torch/optim/lr_scheduler/multi_step_lr"
+require "torch/optim/lr_scheduler/exponential_lr"
+require "torch/optim/lr_scheduler/cosine_annealing_lr"
 
 # nn parameters
 require "torch/nn/parameter"
@@ -59,6 +64,14 @@ require "torch/nn/avg_pool3d"
 require "torch/nn/lp_poolnd"
 require "torch/nn/lp_pool1d"
 require "torch/nn/lp_pool2d"
+require "torch/nn/adaptive_max_poolnd"
+require "torch/nn/adaptive_max_pool1d"
+require "torch/nn/adaptive_max_pool2d"
+require "torch/nn/adaptive_max_pool3d"
+require "torch/nn/adaptive_avg_poolnd"
+require "torch/nn/adaptive_avg_pool1d"
+require "torch/nn/adaptive_avg_pool2d"
+require "torch/nn/adaptive_avg_pool3d"
 
 # nn padding layers
 require "torch/nn/reflection_padnd"
@@ -166,6 +179,9 @@ require "torch/utils/data/tensor_dataset"
 # random
 require "torch/random"
 
+# hub
+require "torch/hub"
+
 module Torch
   class Error < StandardError; end
   class NotImplementedYet < StandardError
@@ -365,6 +381,11 @@ module Torch
     end
 
     def tensor(data, **options)
+      if options[:dtype].nil? && defined?(Numo::NArray) && data.is_a?(Numo::NArray)
+        numo_to_dtype = _dtype_to_numo.map(&:reverse).to_h
+        options[:dtype] = numo_to_dtype[data.class]
+      end
+
       size = []
       if data.respond_to?(:to_a)
         data = data.to_a

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-18 00:00:00.000000000 Z
+date: 2020-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: npy
+  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: []
@@ -106,16 +120,32 @@ 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/hub.rb
 - 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/adaptive_avg_pool1d.rb
+- lib/torch/nn/adaptive_avg_pool2d.rb
+- lib/torch/nn/adaptive_avg_pool3d.rb
+- lib/torch/nn/adaptive_avg_poolnd.rb
+- lib/torch/nn/adaptive_max_pool1d.rb
+- lib/torch/nn/adaptive_max_pool2d.rb
+- lib/torch/nn/adaptive_max_pool3d.rb
+- lib/torch/nn/adaptive_max_poolnd.rb
 - lib/torch/nn/alpha_dropout.rb
 - lib/torch/nn/avg_pool1d.rb
 - lib/torch/nn/avg_pool2d.rb
@@ -224,7 +254,12 @@ files:
 - lib/torch/optim/adamax.rb
 - lib/torch/optim/adamw.rb
 - lib/torch/optim/asgd.rb
+- lib/torch/optim/lr_scheduler/cosine_annealing_lr.rb
+- lib/torch/optim/lr_scheduler/exponential_lr.rb
+- lib/torch/optim/lr_scheduler/lambda_lr.rb
 - lib/torch/optim/lr_scheduler/lr_scheduler.rb
+- lib/torch/optim/lr_scheduler/multi_step_lr.rb
+- lib/torch/optim/lr_scheduler/multiplicative_lr.rb
 - lib/torch/optim/lr_scheduler/step_lr.rb
 - lib/torch/optim/optimizer.rb
 - lib/torch/optim/rmsprop.rb
@@ -235,7 +270,7 @@ files:
 - 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
+homepage: https://github.com/ankane/torch.rb
 licenses:
 - BSD-3-Clause
 metadata: {}