torch-rb 0.1.4 → 0.1.5

data/lib/torch/nn/multi_label_soft_margin_loss.rb

@@ -0,0 +1,13 @@
+module Torch
+  module NN
+    class MultiLabelSoftMarginLoss < WeightedLoss
+      def initialize(weight: nil, reduction: "mean")
+        super(weight, reduction)
+      end
+
+      def forward(input, target)
+        F.multilabel_soft_margin_loss(input, target, weight: @weight, reduction: @reduction)
+      end
+    end
+  end
+end

data/lib/torch/nn/multi_margin_loss.rb

@@ -0,0 +1,17 @@
+module Torch
+  module NN
+    class MultiMarginLoss < WeightedLoss
+      def initialize(p: 1, margin: 1.0, weight: nil, reduction: "mean")
+        super(weight, reduction)
+        raise ArgumentError, "only p == 1 and p == 2 supported" if p != 1 && p != 2
+        raise ArgumentError, "weight must be nil or have one dimension" unless weight.nil? || weight.dim == 1
+        @p = p
+        @margin = margin
+      end
+
+      def forward(input, target)
+        F.multi_margin_loss(input, target, p: @p, margin: @margin, weight: @weight, reduction: @reduction)
+      end
+    end
+  end
+end

data/lib/torch/nn/parameter.rb

@@ -5,6 +5,10 @@ module Torch
         data = Tensor.new unless data
         Tensor._make_subclass(data, requires_grad)
       end
+
+      def inspect
+        "Parameter containing:\n#{super}"
+      end
     end
   end
 end

data/lib/torch/nn/rnn.rb

@@ -0,0 +1,22 @@
+module Torch
+  module NN
+    class RNN < RNNBase
+      def initialize(*args, **options)
+        if options.key?(:nonlinearity)
+          if options[:nonlinearity] == "tanh"
+            mode = "RNN_TANH"
+          elsif options[:nonlinearity] == "relu"
+            mode = "RNN_RELU"
+          else
+            raise ArgumentError, "Unknown nonlinearity: #{options[:nonlinearity]}"
+          end
+          options.delete(:nonlinearity)
+        else
+          mode = "RNN_TANH"
+        end
+
+        super(mode, *args, **options)
+      end
+    end
+  end
+end

data/lib/torch/nn/rnn_base.rb

@@ -0,0 +1,154 @@
+module Torch
+  module NN
+    class RNNBase < Module
+      def initialize(mode, input_size, hidden_size, num_layers: 1, bias: true,
+        batch_first: false, dropout: 0.0, bidirectional: false)
+
+        super()
+        @mode = mode
+        @input_size = input_size
+        @hidden_size = hidden_size
+        @num_layers = num_layers
+        @bias = bias
+        @batch_first = batch_first
+        @dropout = dropout.to_f
+        @bidirectional = bidirectional
+        num_directions = bidirectional ? 2 : 1
+
+        if !dropout.is_a?(Numeric) || !(dropout >= 0 && dropout <= 1)
+          raise ArgumentError, "dropout should be a number in range [0, 1] " +
+                               "representing the probability of an element being " +
+                               "zeroed"
+        end
+        if dropout > 0 && num_layers == 1
+          warn "dropout option adds dropout after all but last " +
+               "recurrent layer, so non-zero dropout expects " +
+               "num_layers greater than 1, but got dropout=#{dropout} and " +
+               "num_layers=#{num_layers}"
+        end
+
+        gate_size =
+          case mode
+          when "LSTM"
+            4 * hidden_size
+          when "GRU"
+            3 * hidden_size
+          when "RNN_TANH"
+            hidden_size
+          when "RNN_RELU"
+            hidden_size
+          else
+            raise ArgumentError, "Unrecognized RNN mode: #{mode}"
+          end
+
+        @all_weights = []
+        num_layers.times do |layer|
+          num_directions.times do |direction|
+            layer_input_size = layer == 0 ? input_size : hidden_size * num_directions
+
+            w_ih = Parameter.new(Torch::Tensor.new(gate_size, layer_input_size))
+            w_hh = Parameter.new(Torch::Tensor.new(gate_size, hidden_size))
+            b_ih = Parameter.new(Torch::Tensor.new(gate_size))
+            # Second bias vector included for CuDNN compatibility. Only one
+            # bias vector is needed in standard definition.
+            b_hh = Parameter.new(Torch::Tensor.new(gate_size))
+            layer_params = [w_ih, w_hh, b_ih, b_hh]
+
+            suffix = direction == 1 ? "_reverse" : ""
+            param_names = ["weight_ih_l%s%s", "weight_hh_l%s%s"]
+            if bias
+              param_names += ["bias_ih_l%s%s", "bias_hh_l%s%s"]
+            end
+            param_names.map! { |x| x % [layer, suffix] }
+
+            param_names.zip(layer_params) do |name, param|
+              instance_variable_set("@#{name}", param)
+            end
+            @all_weights << param_names
+          end
+        end
+
+        flatten_parameters
+        reset_parameters
+      end
+
+      def flatten_parameters
+        # no-op unless module is on the GPU and cuDNN is enabled
+      end
+
+      def _apply(fn)
+        ret = super
+        flatten_parameters
+        ret
+      end
+
+      def reset_parameters
+        stdv = 1.0 / Math.sqrt(@hidden_size)
+        parameters.each do |weight|
+          Init.uniform!(weight, a: -stdv, b: stdv)
+        end
+      end
+
+      def permute_hidden(hx, permutation)
+        raise NotImplementedYet
+      end
+
+      def forward(input, hx: nil)
+        raise NotImplementedYet
+
+        is_packed = false # TODO isinstance(input, PackedSequence)
+        if is_packed
+          input, batch_sizes, sorted_indices, unsorted_indices = input
+          max_batch_size = batch_sizes[0]
+          max_batch_size = max_batch_size.to_i
+        else
+          batch_sizes = nil
+          max_batch_size = @batch_first ? input.size(0) : input.size(1)
+          sorted_indices = nil
+          unsorted_indices = nil
+        end
+
+        if hx.nil?
+          num_directions = @bidirectional ? 2 : 1
+          hx = Torch.zeros(@num_layers * num_directions, max_batch_size,
+            @hidden_size, dtype: input.dtype, device: input.device)
+        else
+          # Each batch of the hidden state should match the input sequence that
+          # the user believes he/she is passing in.
+          hx = permute_hidden(hx, sorted_indices)
+        end
+
+        check_forward_args(input, hx, batch_sizes)
+        _rnn_impls = {
+          "RNN_TANH" => Torch.method(:_rnn_tanh),
+          "RNN_RELU" => Torch.method(:_rnn_relu)
+        }
+        _impl = _rnn_impls[@mode]
+        if batch_sizes.nil?
+          result = _impl.call(input, hx, _get_flat_weights, @bias, @num_layers,
+                           @dropout, @training, @bidirectional, @batch_first)
+        else
+          result = _impl.call(input, batch_sizes, hx, _get_flat_weights, @bias,
+                           @num_layers, @dropout, @training, @bidirectional)
+        end
+        output = result[0]
+        hidden = result[1]
+
+        if is_packed
+          raise NotImplementedYet
+          # output = PackedSequence(output, batch_sizes, sorted_indices, unsorted_indices)
+        end
+        [output, permute_hidden(hidden, unsorted_indices)]
+      end
+
+      # TODO add more parameters
+      def extra_inspect
+        s = String.new("%{input_size}, %{hidden_size}")
+        if @num_layers != 1
+          s += ", num_layers: %{num_layers}"
+        end
+        format(s, input_size: @input_size, hidden_size: @hidden_size, num_layers: @num_layers)
+      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/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/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
@@ -57,7 +53,7 @@ module Torch
       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
@@ -73,7 +69,7 @@ module Torch
     def numo
       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)
@@ -90,25 +86,27 @@ module Torch
       _type(enum)
     end
 
+    # start temp operations
+
     def add!(value = 1, other)
       if other.is_a?(Numeric)
-        _add_scalar!(other * value)
+        _add__scalar(other, value)
       else
         # need to use alpha for sparse tensors instead of multiplying
-        _add_alpha!(other, value)
+        _add__tensor(other, value)
       end
     end
 
     def mul!(other)
       if other.is_a?(Numeric)
-        _mul_scalar!(other)
+        _mul__scalar(other)
       else
-        _mul!(other)
+        _mul__tensor(other)
       end
     end
 
     # operations
-    %w(abs add argmax div dot eq exp gt log log_softmax lt matmul max mean min mul neg norm num numel pow relu remainder reshape sign softmax sqrt sub sum unsqueeze topk).each do |op|
+    %w(log_softmax mean softmax sum topk).each do |op|
       define_method(op) do |*args, **options, &block|
         if options.any?
           Torch.send(op, self, *args, **options, &block)
@@ -118,6 +116,8 @@ module Torch
       end
     end
 
+    # end temp operations
+
     def +(other)
       add(other)
     end
@@ -156,11 +156,11 @@ 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)
@@ -183,11 +183,11 @@ module Torch
       value = Torch.tensor(value) unless value.is_a?(Tensor)
 
       if index.is_a?(Numeric)
-        copy_to(_select(0, index), value)
+        copy_to(_select_int(0, index), value)
       elsif index.is_a?(Range)
         finish = index.end
         finish += 1 unless index.exclude_end?
-        copy_to(_slice(0, index.begin, finish, 1), value)
+        copy_to(_slice_tensor(0, index.begin, finish, 1), value)
       else
         raise Error, "Unsupported index type: #{index.class.name}"
       end

data/lib/torch/version.rb

@@ -1,3 +1,3 @@
 module Torch
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torch-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-01 00:00:00.000000000 Z
+date: 2019-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -106,17 +106,31 @@ files:
 - README.md
 - ext/torch/ext.cpp
 - ext/torch/extconf.rb
+- ext/torch/nn_functions.cpp
+- ext/torch/nn_functions.hpp
+- 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_pool2d.rb
 - lib/torch/nn/avg_poolnd.rb
 - lib/torch/nn/bce_loss.rb
+- lib/torch/nn/bce_with_logits_loss.rb
 - lib/torch/nn/bilinear.rb
 - lib/torch/nn/conv2d.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
@@ -128,6 +142,7 @@ files:
 - lib/torch/nn/embedding_bag.rb
 - lib/torch/nn/feature_alpha_dropout.rb
 - lib/torch/nn/functional.rb
+- lib/torch/nn/hinge_embedding_loss.rb
 - lib/torch/nn/identity.rb
 - lib/torch/nn/init.rb
 - lib/torch/nn/kl_div_loss.rb
@@ -136,22 +151,31 @@ files:
 - lib/torch/nn/linear.rb
 - lib/torch/nn/log_softmax.rb
 - lib/torch/nn/loss.rb
+- lib/torch/nn/margin_ranking_loss.rb
 - lib/torch/nn/max_pool2d.rb
 - lib/torch/nn/max_poolnd.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/relu.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/triplet_margin_loss.rb
 - lib/torch/nn/weighted_loss.rb
 - lib/torch/optim/adadelta.rb
 - lib/torch/optim/adagrad.rb