torch-rb 0.1.3 → 0.1.8

data/lib/torch/nn/sequential.rb

@@ -2,28 +2,19 @@ module Torch
   module NN
     class Sequential < Module
       def initialize(*args)
-        @modules = {}
+        super()
         # 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/nn/sigmoid.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class Sigmoid < Module
+      def forward(input)
+        Torch.sigmoid(input)
+      end
+    end
+  end
+end

data/lib/torch/nn/smooth_l1_loss.rb

@@ -0,0 +1,13 @@
+module Torch
+  module NN
+    class SmoothL1Loss < Loss
+      def initialize(reduction: "mean")
+        super(reduction)
+      end
+
+      def forward(input, target)
+        F.smooth_l1_loss(input, target, reduction: @reduction)
+      end
+    end
+  end
+end

data/lib/torch/nn/soft_margin_loss.rb

@@ -0,0 +1,13 @@
+module Torch
+  module NN
+    class SoftMarginLoss < Loss
+      def initialize(reduction: "mean")
+        super(reduction)
+      end
+
+      def forward(input, target)
+        F.soft_margin_loss(input, target, reduction: @reduction)
+      end
+    end
+  end
+end

data/lib/torch/nn/softmax.rb

@@ -0,0 +1,18 @@
+module Torch
+  module NN
+    class Softmax < Module
+      def initialize(dim: nil)
+        super()
+        @dim = dim
+      end
+
+      def forward(input)
+        F.softmax(input, dim: @dim)
+      end
+
+      def extra_inspect
+        format("dim: %s", @dim)
+      end
+    end
+  end
+end

data/lib/torch/nn/softmax2d.rb

@@ -0,0 +1,10 @@
+module Torch
+  module NN
+    class Softmax2d < Module
+      def forward(input)
+        raise ArgumentError, "Softmax2d requires a 4D tensor as input" unless input.dim == 4
+        F.softmax(input, dim: 1)
+      end
+    end
+  end
+end

data/lib/torch/nn/softmin.rb

@@ -0,0 +1,14 @@
+module Torch
+  module NN
+    class Softmin < Module
+      def initialize(dim: nil)
+        super()
+        @dim = dim
+      end
+
+      def forward(input)
+        F.softmin(input, dim: @dim)
+      end
+    end
+  end
+end

data/lib/torch/nn/softplus.rb

@@ -0,0 +1,19 @@
+module Torch
+  module NN
+    class Softplus < Module
+      def initialize(beta: 1, threshold: 20)
+        super()
+        @beta = beta
+        @threshold = threshold
+      end
+
+      def forward(input)
+        F.softplus(input, beta: @beta, threshold: @threshold)
+      end
+
+      def extra_inspect
+        format("beta: %s, threshold: %s", @beta, @threshold)
+      end
+    end
+  end
+end

data/lib/torch/nn/softshrink.rb

@@ -0,0 +1,18 @@
+module Torch
+  module NN
+    class Softshrink < Module
+      def initialize(lambd: 0.5)
+        super()
+        @lambd = lambd
+      end
+
+      def forward(input)
+        F.softshrink(input, @lambd)
+      end
+
+      def extra_inspect
+        @lambd.to_s
+      end
+    end
+  end
+end

data/lib/torch/nn/softsign.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class Softsign < Module
+      def forward(input)
+        F.softsign(input)
+      end
+    end
+  end
+end

data/lib/torch/nn/tanh.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class Tanh < Module
+      def forward(input)
+        Torch.tanh(input)
+      end
+    end
+  end
+end

data/lib/torch/nn/tanhshrink.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class Tanhshrink < Module
+      def forward(input)
+        F.tanhshrink(input)
+      end
+    end
+  end
+end

data/lib/torch/nn/triplet_margin_loss.rb

@@ -0,0 +1,18 @@
+module Torch
+  module NN
+    class TripletMarginLoss < Loss
+      def initialize(margin: 1.0, p: 2.0, eps: 1e-6, swap: false, reduction: "mean")
+        super(reduction)
+        @margin = margin
+        @p = p
+        @eps = eps
+        @swap = swap
+      end
+
+      def forward(anchor, positive, negative)
+        F.triplet_margin_loss(anchor, positive, negative, margin: @margin, p: @p,
+                              eps: @eps, swap: @swap, reduction: @reduction)
+      end
+    end
+  end
+end

data/lib/torch/nn/unfold.rb

@@ -0,0 +1,19 @@
+module Torch
+  module NN
+    class Unfold < Module
+      def initialize(kernel_size, dilation: 1, padding: 0, stride: 1)
+        super()
+        @kernel_size = kernel_size
+        @dilation = dilation
+        @padding = padding
+        @stride = stride
+      end
+
+      def forward(input)
+        F.unfold(input, @kernel_size, dilation: @dilation, padding: @padding, stride: @stride)
+      end
+
+      # TODO add extra_inspect
+    end
+  end
+end

data/lib/torch/nn/utils.rb

@@ -0,0 +1,25 @@
+module Torch
+  module NN
+    module Utils
+      def _single(value)
+        _ntuple(1, value)
+      end
+
+      def _pair(value)
+        _ntuple(2, value)
+      end
+
+      def _triple(value)
+        _ntuple(3, value)
+      end
+
+      def _quadrupal(value)
+        _ntuple(4, value)
+      end
+
+      def _ntuple(n, value)
+        value.is_a?(Array) ? value : [value] * n
+      end
+    end
+  end
+end

data/lib/torch/nn/weighted_loss.rb

@@ -0,0 +1,10 @@
+module Torch
+  module NN
+    class WeightedLoss < Loss
+      def initialize(weight, reduction)
+        super(reduction)
+        register_buffer("weight", weight)
+      end
+    end
+  end
+end

data/lib/torch/nn/zero_pad2d.rb

@@ -0,0 +1,9 @@
+module Torch
+  module NN
+    class ZeroPad2d < ConstantPad2d
+      def initialize(padding)
+        super(padding, 0.0)
+      end
+    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.length == 1 && size.first.is_a?(Tensor)
-        size.first
-      else
-        Torch.empty(*size)
-      end
+    def self.new(*args)
+      FloatTensor.new(*args)
     end
 
     def dtype
@@ -28,7 +24,7 @@ module Torch
     end
 
     def to_a
-      reshape_arr(_data, shape)
+      reshape_arr(_flat_data, shape)
     end
 
     # TODO support dtype
@@ -39,7 +35,7 @@ module Torch
 
     def size(dim = nil)
       if dim
-        _size(dim)
+        _size_int(dim)
       else
         shape
       end
@@ -49,15 +45,16 @@ 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
@@ -66,19 +63,14 @@ module Torch
     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)
@@ -95,31 +87,23 @@ module Torch
       _type(enum)
     end
 
-    def add!(value = 1, other)
-      if other.is_a?(Numeric)
-        _add_scalar!(other * value)
-      else
-        # need to use alpha for sparse tensors instead of multiplying
-        _add_alpha!(other, value)
-      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 mul!(other)
-      if other.is_a?(Numeric)
-        _mul_scalar!(other)
-      else
-        _mul!(other)
-      end
+    def view(*size)
+      size = size.first if size.size == 1 && size.first.is_a?(Array)
+      _view(size)
     end
 
-    # operations
-    %w(abs add argmax div dot eq exp gt log lt matmul max mean min mul neg norm num numel pow remainder reshape sign sqrt sub sum 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
+    # 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
 
@@ -161,14 +145,20 @@ module Torch
       dim = 0
       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
@@ -176,11 +166,28 @@ module Torch
 
     # TODO
     # based on python_variable_indexing.cpp
-    # def []=(index, value)
-    # end
+    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