ruby-dnn 1.1.4 → 1.2.2

data/lib/dnn/core/layers/split_layers.rb

@@ -0,0 +1,39 @@
+module DNN
+  module Layers
+
+    class Split < Layer
+      include LayerNode
+
+      attr_reader :axis
+      attr_reader :dim
+
+      def initialize(axis: 1, dim: nil)
+        super()
+        raise DNNError, "dim is nil" if dim == nil
+        @axis = axis
+        @dim = dim
+      end
+
+      def forward_node(x)
+        x1_dim = @dim
+        x2_dim = x.shape[@axis] - @dim
+        y1, y2others = x.split([x1_dim, x1_dim + x2_dim], axis: @axis)
+        y2 = y2others.is_a?(Array) ? y2others[0].concatenate(y2others[1..-1], axis: @axis) : y2others
+        [y1, y2]
+      end
+
+      def backward_node(dy1, dy2)
+        dy1.concatenate(dy2, axis: @axis)
+      end
+
+      def to_hash
+        super(axis: @axis, dim: @dim)
+      end
+
+      def load_hash(hash)
+        initialize(axis: hash[:axis], dim: hash[:dim])
+      end
+    end
+
+  end
+end

data/lib/dnn/core/link.rb

@@ -1,57 +1,38 @@
 module DNN
   class Link
-    attr_accessor :prev
+    attr_accessor :prevs
     attr_accessor :next
     attr_accessor :layer_node
+    attr_reader :num_outputs
 
-    def initialize(prev = nil, layer_node = nil)
-      @prev = prev
-      @layer_node = layer_node
-      @next = nil
-    end
-
-    def forward(x)
-      x = @layer_node.(x)
-      @next ? @next.forward(x) : x
-    end
-
-    def backward(dy = Xumo::SFloat[1])
-      dy = @layer_node.backward_node(dy)
-      @prev&.backward(dy)
-    end
-  end
-
-  class TwoInputLink
-    attr_accessor :prev1
-    attr_accessor :prev2
-    attr_accessor :next
-    attr_accessor :layer_node
-
-    def initialize(prev1 = nil, prev2 = nil, layer_node = nil)
-      @prev1 = prev1
-      @prev2 = prev2
+    def initialize(prevs: nil, layer_node: nil, num_outputs: 1)
+      @prevs = prevs
       @layer_node = layer_node
+      @num_outputs = num_outputs
       @next = nil
       @hold = []
     end
 
     def forward(x)
       @hold << x
-      return if @hold.length < 2
+      return if @hold.length < @prevs.length
       x = @layer_node.(*@hold)
       @hold = []
       @next ? @next.forward(x) : x
     end
 
     def backward(dy = Xumo::SFloat[1])
-      dys = @layer_node.backward_node(dy)
+      @hold << dy
+      return if @hold.length < @num_outputs
+      dys = @layer_node.backward_node(*@hold)
+      @hold = []
       if dys.is_a?(Array)
-        dy1, dy2 = *dys
+        dys.each.with_index do |dy, i|
+          @prevs[i]&.backward(dy)
+        end
       else
-        dy1 = dys
+        @prevs.first&.backward(dys)
       end
-      @prev1&.backward(dy1)
-      @prev2&.backward(dy2) if dy2
     end
   end
 end

data/lib/dnn/core/losses.rb

@@ -42,12 +42,6 @@ module DNN
         loss
       end
 
-      def regularizers_backward(layers)
-        layers.select { |layer| layer.respond_to?(:regularizers) }.each do |layer|
-          layer.regularizers.each(&:backward)
-        end
-      end
-
       def to_hash(merge_hash = nil)
         hash = { class: self.class.name }
         hash.merge!(merge_hash) if merge_hash
@@ -68,7 +62,7 @@ module DNN
     end
 
     class MeanSquaredError < Loss
-      include Layers::MergeLayerNode
+      include Layers::LayerNode
 
       def forward_node(y, t)
         @y = y
@@ -82,7 +76,7 @@ module DNN
     end
 
     class MeanAbsoluteError < Loss
-      include Layers::MergeLayerNode
+      include Layers::LayerNode
 
       def forward_node(y, t)
         @y = y
@@ -99,7 +93,7 @@ module DNN
     end
 
     class Hinge < Loss
-      include Layers::MergeLayerNode
+      include Layers::LayerNode
 
       def forward_node(y, t)
         @t = t
@@ -115,7 +109,7 @@ module DNN
     end
 
     class HuberLoss < Loss
-      include Layers::MergeLayerNode
+      include Layers::LayerNode
 
       def forward_node(y, t)
         @y = y
@@ -135,7 +129,7 @@ module DNN
     end
 
     class SoftmaxCrossEntropy < Loss
-      include Layers::MergeLayerNode
+      include Layers::LayerNode
 
       attr_accessor :eps
 
@@ -172,7 +166,7 @@ module DNN
     end
 
     class SigmoidCrossEntropy < Loss
-      include Layers::MergeLayerNode
+      include Layers::LayerNode
 
       attr_accessor :eps
 

data/lib/dnn/core/models.rb

@@ -230,6 +230,7 @@ module DNN
             puts "【 epoch #{epoch}/#{epochs} 】" if verbose
 
             train_iterator.foreach(batch_size) do |x_batch, y_batch, index|
+              @last_log[:step] = index
               train_step_met = train_step(x_batch, y_batch)
               num_trained_datas = (index + 1) * batch_size
               num_trained_datas = num_trained_datas > num_train_datas ? num_train_datas : num_trained_datas
@@ -305,13 +306,13 @@ module DNN
             loss_opt[:layers] = layers if i == 0
             loss_opt[:loss_weight] = @loss_weights[i] if @loss_weights
             loss = @loss_func[i].loss(out, Tensor.convert(y[i]), **loss_opt)
-            loss_data << loss.data.to_f
+            loss_data << Utils.to_f(loss.data)
             loss.link.backward(Xumo::SFloat.ones(y[i][0...1, false].shape[0], 1))
           end
         else
           out = output_tensors
           loss = @loss_func.loss(out, Tensor.convert(y), layers: layers)
-          loss_data = loss.data.to_f
+          loss_data = Utils.to_f(loss.data)
           loss.link.backward(Xumo::SFloat.ones(y[0...1, false].shape[0], 1))
         end
         @optimizer.update(get_all_trainable_params)
@@ -392,13 +393,13 @@ module DNN
           output_tensors.each.with_index do |out, i|
             correct << accuracy(out.data, y[i]) if accuracy
             loss = @loss_func[i].(out, Tensor.convert(y[i]))
-            loss_data << loss.data.to_f
+            loss_data << Utils.to_f(loss.data)
           end
         else
           out = output_tensors
           correct = accuracy(out.data, y) if accuracy
           loss = @loss_func.(out, Tensor.convert(y))
-          loss_data = loss.data.to_f
+          loss_data = Utils.to_f(loss.data)
         end
         call_callbacks(:after_test_on_batch)
         [correct, loss_data]
@@ -441,8 +442,9 @@ module DNN
         ys = []
         ary_output_tensors.each.with_index do |out, i|
           y = out.data
-          if use_loss_activation && lfs[i].class.respond_to?(:activation)
-            y = lfs[i].class.activation(y)
+          lf = lfs[i]
+          if use_loss_activation && lf && lf.class.respond_to?(:activation)
+            y = lf.class.activation(y)
           end
           ys << y
         end
@@ -458,7 +460,12 @@ module DNN
                 else
                   x.reshape(1, *x.shape)
                 end
-        predict(input, use_loss_activation: use_loss_activation)[0, false]
+        y = predict(input, use_loss_activation: use_loss_activation)
+        if y.is_a?(Array)
+          y.map { |v| v[0, false] }
+        else
+          y[0, false]
+        end
       end
 
       # Add callback function.
@@ -468,6 +475,15 @@ module DNN
         @callbacks << callback
       end
 
+      # Add lambda callback.
+      # @param [Symbol] event Event to execute callback.
+      # @yield Register the contents of the callback.
+      def add_lambda_callback(event, &block)
+        callback = Callbacks::LambdaCallback.new(event, &block)
+        callback.model = self
+        @callbacks << callback
+      end
+
       # Clear the callback function registered for each event.
       def clear_callbacks
         @callbacks = []
@@ -526,7 +542,7 @@ module DNN
           @loss_func.each do |lf|
             lf.clean
           end
-        else
+        elsif @loss_func.is_a?(Losses::Loss)
           @loss_func.clean
         end
         @layers_cache = nil
@@ -552,6 +568,56 @@ module DNN
         end
       end
 
+      # Convert the parameters of model and optimizer for cpu.
+      # @return [DNN::Models::Model] Return self.
+      def to_cpu
+        params_data = get_all_params_data
+        clean_layers
+        set_all_params_data(params_data)
+        trainable_layers.each do |layer|
+          layer.get_params.each do |key, param|
+            data = param.data
+            if DNN.use_cumo? && data.is_a?(Cumo::NArray)
+              param.data = Utils.cumo2numo(data)
+            end
+          end
+        end
+        @optimizer.status.each do |key, state|
+          next unless state
+          state.each do |param, data|
+            if DNN.use_cumo? && data.is_a?(Cumo::NArray)
+              state[param] = Utils.cumo2numo(data)
+            end
+          end
+        end
+        self
+      end
+
+      # Convert the parameters of model and optimizer for gpu.
+      # @return [DNN::Models::Model] Return self.
+      def to_gpu
+        params_data = get_all_params_data
+        clean_layers
+        set_all_params_data(params_data)
+        trainable_layers.each do |layer|
+          layer.get_params.each do |(key, param)|
+            data = param.data
+            if DNN.use_cumo? && data.is_a?(Numo::NArray)
+              param.data = Utils.numo2cumo(data)
+            end
+          end
+        end
+        @optimizer.status.each do |(key, state)|
+          next unless state
+          state.each do |(param, data)|
+            if DNN.use_cumo? && data.is_a?(Numo::NArray)
+              state[param] = Utils.numo2cumo(data)
+            end
+          end
+        end
+        self
+      end
+
       private
 
       def get_all_trainable_params
@@ -569,10 +635,10 @@ module DNN
       def metrics_to_str(mertics)
         mertics.map { |key, values|
           str_values = if values.is_a?(Array)
-                         values_fmt = values.map { |v| sprintf('%.4f', v) }
+                         values_fmt = values.map { |v| sprintf('%.4f', Utils.to_f(v)) }
                          "[#{values_fmt.join(", ")}]"
                        else
-                         sprintf('%.4f', values)
+                         sprintf('%.4f', Utils.to_f(values))
                        end
           "#{key}: #{str_values}"
         }.join(", ")
@@ -641,6 +707,7 @@ module DNN
           raise TypeError, "layer: #{layer.class.name} is not an instance of the DNN::Layers::Layer class or DNN::Models::Chain class."
         end
         @stack.insert(index, layer)
+        self
       end
 
       # Remove layer to the model.

data/lib/dnn/core/optimizers.rb

@@ -3,6 +3,7 @@ module DNN
 
     # Super class of all optimizer classes.
     class Optimizer
+      attr_reader :status
       attr_accessor :clip_norm
 
       def self.from_hash(hash)
@@ -47,7 +48,7 @@ module DNN
       end
 
       private def clip_grads(params)
-        norm = Math.sqrt(params.reduce(0) { |total, param| total + (param.grad**2).sum })
+        norm = Math.sqrt(params.reduce(0) { |total, param| total + (param.grad**2).sum.to_f })
         return if norm <= @clip_norm
         rate = @clip_norm / (norm + 1e-7)
         params.each do |param|
@@ -71,6 +72,7 @@ module DNN
         @lr = lr
         @momentum = momentum
         @v = {}
+        @status = { v: @v }
       end
 
       def to_hash
@@ -120,6 +122,7 @@ module DNN
         @lr = lr
         @eps = eps
         @g = {}
+        @status = { g: @g }
       end
 
       private def update_params(params)
@@ -153,6 +156,7 @@ module DNN
         @alpha = alpha
         @eps = eps
         @g = {}
+        @status = { g: @g }
       end
 
       def to_hash
@@ -184,6 +188,7 @@ module DNN
         @eps = eps
         @h = {}
         @s = {}
+        @status = { h: @h, s: @s }
       end
 
       def to_hash
@@ -221,6 +226,7 @@ module DNN
         @eps = eps
         @m = {}
         @v = {}
+        @status = { m: @m, v: @v }
       end
 
       def to_hash
@@ -265,6 +271,7 @@ module DNN
         @m = {}
         @v = {}
         @s = amsgrad ? {} : nil
+        @status = { m: @m, v: @v, s: @s }
       end
 
       def to_hash

data/lib/dnn/core/utils.rb

@@ -43,5 +43,28 @@ module DNN
     def self.numerical_grad(x, func)
       (func.(x + 1e-7) - func.(x)) / 1e-7
     end
+
+    # Convert numo to cumo.
+    def self.numo2cumo(na)
+      b = na.to_binary
+      ca = Cumo::SFloat.from_binary(b)
+      ca.reshape(*na.shape)
+    end
+
+    # Convert cumo to numo.
+    def self.cumo2numo(ca)
+      b = ca.to_binary
+      na = Numo::SFloat.from_binary(b)
+      na.reshape(*ca.shape)
+    end
+
+    # Force convert to Float.
+    def self.to_f(x)
+      if x.is_a?(Xumo::NArray)
+        x[0].to_f
+      else
+        x.to_f
+      end
+    end
   end
 end

data/lib/dnn/image.rb

@@ -64,6 +64,19 @@ module DNN
       raise ImageWriteError, "Image write failed." if res == 0
     end
 
+    # Create an image from binary.
+    # @param [String] bin binary data.
+    # @param [Integer] height Image height.
+    # @param [Integer] width Image width.
+    # @param [Integer] channel Image channel.
+    def self.from_binary(bin, height, width, channel = DNN::Image::RGB)
+      expected_size = height * width * channel
+      unless bin.size == expected_size
+        raise ImageError, "binary size is #{bin.size}, but expected binary size is #{expected_size}"
+      end
+      Numo::UInt8.from_binary(bin).reshape(height, width, channel)
+    end
+
     # Resize the image.
     # @param [Numo::UInt8] img Image to resize.
     # @param [Integer] out_height Image height to resize.
@@ -101,6 +114,41 @@ module DNN
       Numo::UInt8.cast(x)
     end
 
+    # Image convert image channel to RGB.
+    # @param [Numo::UInt8] img Image to RGB.
+    def self.to_rgb(img)
+      img_check(img)
+      case img.shape[2]
+      when 1
+        return img.concatenate(img, axis: 2).concatenate(img, axis: 2)
+      when 2
+        img = img[true, true, 0...1]
+        return img.concatenate(img, axis: 2).concatenate(img, axis: 2)
+      when 4
+        return img[true, true, 0...3].clone
+      end
+      img
+    end
+
+    # Image convert image channel to RGBA.
+    # @param [Numo::UInt8] img Image to RGBA.
+    def self.to_rgba(img)
+      img_check(img)
+      case img.shape[2]
+      when 1
+        alpha = Numo::UInt8.new(*img.shape[0..1], 1).fill(255)
+        return img.concatenate(img, axis: 2).concatenate(img, axis: 2).concatenate(alpha, axis: 2)
+      when 2
+        alpha = img[true, true, 1...2]
+        img = img[true, true, 0...1]
+        return img.concatenate(img, axis: 2).concatenate(img, axis: 2).concatenate(alpha, axis: 2)
+      when 3
+        alpha = Numo::UInt8.new(*img.shape[0..1], 1).fill(255)
+        return img.concatenate(alpha, axis: 2)
+      end
+      img
+    end
+
     private_class_method def self.img_check(img)
       raise TypeError, "img: #{img.class} is not an instance of the Numo::UInt8 class." unless img.is_a?(Numo::UInt8)
       if img.shape.length != 3