ruby-dnn 0.12.4 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2835cd619265328ffa05c41515915aaeb54924ca4ddd4958edba992ea4feda89
-  data.tar.gz: 5ab01dbcf1219cdfac7b3a0e20bc5783fa15baaf82225ea1a9a2d076569cb7f1
+  metadata.gz: 5a0f021b01f03d45c51e52a1147b05703f8da8895380560d4add4fd3f2fc3d90
+  data.tar.gz: 2c5b3b04d23b0285a0acd1fbde3ca4f774948645d016c471264484f45230fa6f
 SHA512:
-  metadata.gz: 1335b77cf701501930e32f07a9faa027706b908d79a24b1b369228b45c5ef15a38ac476c6951d14b7ce398b1eb7789bf0c96566427b84fffb1ed892af7e43629
-  data.tar.gz: baf8ceeec91699a75a14bde79e815561189e26c9317e34f09580f90f45562120ba12540a7a64e42e562d4d26162490b6c2170721459b8e635731e900812a357b
+  metadata.gz: 33758acb29f83b8523accd213293c84d4b887591926de256e38bd41895f86358c80ee64f2876cd4fb679a9a2c71a64929780149a324dd80020f5b6d397c9a608
+  data.tar.gz: 6a8e95ca8c57a968a846562ad4fa921e382cef83c0839599651ab93ad2d7f6d6cb0c36ada945fb125c0b13e10aa1333030ce019b138146b00e19ed9882237ae7

data/examples/cifar100_example.rb

@@ -1,5 +1,5 @@
 require "dnn"
-require "dnn/cifar100"
+require "dnn/datasets/cifar100"
 # If you use numo/linalg then please uncomment out.
 # require "numo/linalg/autoloader"
 

data/examples/cifar10_example.rb

@@ -1,5 +1,5 @@
 require "dnn"
-require "dnn/cifar10"
+require "dnn/datasets/cifar10"
 # If you use numo/linalg then please uncomment out.
 # require "numo/linalg/autoloader"
 

data/examples/dcgan/dcgan.rb

@@ -68,9 +68,13 @@ class Discriminator < Model
   end
 
   def call(x, trainable = true)
-    has_param_layers.each do |layer|
-      layer.trainable = trainable
-    end
+    @l1.trainable = trainable
+    @l2.trainable = trainable
+    @l3.trainable = trainable
+    @l4.trainable = trainable
+    @l5.trainable = trainable
+    @l6.trainable = trainable
+
     x = InputLayer.new([28, 28, 1]).(x)
     x = @l1.(x)
     x = LeakyReLU.(x, 0.2)

data/examples/dcgan/imgen.rb

@@ -7,7 +7,7 @@ Image = DNN::Image
 
 batch_size = 100
 
-dcgan = Model.load("trained/dcgan_model_epoch20.marshal")
+dcgan = DCGAN.load("trained/dcgan_model_epoch20.marshal")
 gen = dcgan.gen
 
 Numo::SFloat.srand(rand(1 << 31))

data/examples/dcgan/train.rb

@@ -1,5 +1,5 @@
 require "dnn"
-require "dnn/mnist"
+require "dnn/datasets/mnist"
 require "numo/linalg/autoloader"
 require_relative "dcgan"
 
@@ -22,9 +22,11 @@ x_train = Numo::SFloat.cast(x_train)
 x_train = x_train / 127.5 - 1
 
 iter = DNN::Iterator.new(x_train, y_train)
+num_batchs = x_train.shape[0] / batch_size
 (1..epochs).each do |epoch|
   puts "epoch: #{epoch}"
-  iter.foreach(batch_size) do |x_batch, y_batch, index|
+  num_batchs.times do |index|
+    x_batch, y_batch = iter.next_batch(batch_size)
     noise = Numo::SFloat.new(batch_size, 20).rand(-1, 1)
     images = gen.predict(noise)
     x = x_batch.concatenate(images)
@@ -37,5 +39,6 @@ iter = DNN::Iterator.new(x_train, y_train)
 
     puts "index: #{index}, dis_loss: #{dis_loss.mean}, dcgan_loss: #{dcgan_loss.mean}"
   end
+  iter.reset
   dcgan.save("trained/dcgan_model_epoch#{epoch}.marshal")
 end

data/examples/iris_example.rb

@@ -1,5 +1,5 @@
 require "dnn"
-require "dnn/iris"
+require "dnn/datasets/iris"
 # If you use numo/linalg then please uncomment out.
 # require "numo/linalg/autoloader"
 

data/examples/mnist_conv2d_example.rb

@@ -1,5 +1,5 @@
 require "dnn"
-require "dnn/mnist"
+require "dnn/datasets/mnist"
 # If you use numo/linalg then please uncomment out.
 # require "numo/linalg/autoloader"
 

data/examples/mnist_define_by_run.rb

@@ -1,5 +1,5 @@
 require "dnn"
-require "dnn/mnist"
+require "dnn/datasets/mnist"
 # If you use numo/linalg then please uncomment out.
 # require "numo/linalg/autoloader"
 

data/examples/mnist_example.rb

@@ -1,5 +1,5 @@
 require "dnn"
-require "dnn/mnist"
+require "dnn/datasets/mnist"
 # If you use numo/linalg then please uncomment out.
 # require "numo/linalg/autoloader"
 

data/examples/mnist_lstm_example.rb

@@ -1,5 +1,5 @@
 require "dnn"
-require "dnn/mnist"
+require "dnn/datasets/mnist"
 # If you use numo/linalg then please uncomment out.
 # require "numo/linalg/autoloader"
 

data/lib/dnn.rb

@@ -9,6 +9,7 @@ end
 
 require_relative "dnn/version"
 require_relative "dnn/core/error"
+require_relative "dnn/core/global"
 require_relative "dnn/core/models"
 require_relative "dnn/core/param"
 require_relative "dnn/core/link"
@@ -24,4 +25,5 @@ require_relative "dnn/core/cnn_layers"
 require_relative "dnn/core/embedding"
 require_relative "dnn/core/rnn_layers"
 require_relative "dnn/core/optimizers"
+require_relative "dnn/core/savers"
 require_relative "dnn/core/utils"

data/lib/dnn/core/embedding.rb

@@ -28,9 +28,8 @@ module DNN
       end
 
       def call(input)
-        x, *, learning_phase = *input
         build unless built?
-        [forward(x), Link.new(nil, self), learning_phase]
+        [forward(input), Link.new(nil, self)]
       end
 
       def build

data/lib/dnn/core/error.rb

@@ -2,4 +2,6 @@ module DNN
   class DNN_Error < StandardError; end
 
   class DNN_ShapeError < DNN_Error; end
+
+  class DNN_UnknownEventError < DNN_Error; end
 end

data/lib/dnn/core/global.rb

@@ -0,0 +1,9 @@
+module DNN
+  def self.learning_phase
+    @learning_phase
+  end
+
+  def self.learning_phase=(bool)
+    @learning_phase = bool
+  end
+end

data/lib/dnn/core/initializers.rb

@@ -2,7 +2,7 @@ module DNN
   module Initializers
 
     class Initializer
-      # @param [Boolean | Integer] seed Seed of random number used for masking.
+      # @param [Boolean | Integer] seed Seed of random number used for initialize parameter.
       #                                 Set true to determine seed as random.
       def initialize(seed: false)
         @seed = seed == true ? rand(1 << 31) : seed

data/lib/dnn/core/iterator.rb

@@ -8,7 +8,7 @@ module DNN
       @x_datas = x_datas
       @y_datas = y_datas
       @random = random
-      @num_datas = x_datas.shape[0]
+      @num_datas = x_datas.is_a?(Array) ? x_datas[0].shape[0] : x_datas.shape[0]
       reset
     end
 
@@ -22,8 +22,16 @@ module DNN
       else
         batch_indexes = @indexes.shift(batch_size)
       end
-      x_batch = @x_datas[batch_indexes, false]
-      y_batch = @y_datas[batch_indexes, false]
+      x_batch = if @x_datas.is_a?(Array)
+        @x_datas.map { |datas| datas[batch_indexes, false] }
+      else
+        @x_datas[batch_indexes, false]
+      end
+      y_batch = if @y_datas.is_a?(Array)
+        @y_datas.map { |datas| datas[batch_indexes, false] }
+      else
+        @y_datas[batch_indexes, false]
+      end
       [x_batch, y_batch]
     end
 

data/lib/dnn/core/layers.rb

@@ -3,6 +3,7 @@ module DNN
 
     # Super class of all layer classes.
     class Layer
+      attr_accessor :name
       attr_reader :input_shape
 
       def self.call(x, *args)
@@ -14,13 +15,13 @@ module DNN
       end
 
       # Forward propagation and create a link.
-      # @param [Array] input Array of the form [x_input_data, prev_link, learning_phase].
+      # @param [Array] input Array of the form [x_input_data, prev_link].
       def call(input)
-        x, prev_link, learning_phase = *input
+        x, prev_link = *input
         build(x.shape[1..-1]) unless built?
         y = forward(x)
         link = Link.new(prev_link, self)
-        [y, link, learning_phase]
+        [y, link]
       end
 
       # Build the layer.
@@ -98,9 +99,14 @@ module DNN
 
       def call(input)
         build unless built?
-        x, prev_link, learning_phase = *input
+        if input.is_a?(Array)
+          x, prev_link = *input
+        else
+          x = input
+          prev_link = nil
+        end
         link = prev_link ? Link.new(prev_link, self) : Link.new(nil, self)
-        [forward(x), link, learning_phase]
+        [forward(x), link]
       end
 
       def build
@@ -310,16 +316,8 @@ module DNN
         @rnd = Random.new(@seed)
       end
 
-      def call(input)
-        x, prev_link, learning_phase = *input
-        build(x.shape[1..-1]) unless built?
-        y = forward(x, learning_phase)
-        link = Link.new(prev_link, self)
-        [y, link, learning_phase]
-      end
-
-      def forward(x, learning_phase)
-        if learning_phase
+      def forward(x)
+        if DNN.learning_phase
           Xumo::SFloat.srand(@rnd.rand(1 << 31))
           @mask = Xumo::SFloat.ones(*x.shape).rand < @dropout_ratio
           x[@mask] = 0

data/lib/dnn/core/link.rb

@@ -7,6 +7,11 @@ module DNN
       @prev = prev
       @layer = layer
     end
+
+    def backward(dy)
+      dy = @layer.backward(dy)
+      @prev&.backward(dy)
+    end
   end
 
 
@@ -20,5 +25,11 @@ module DNN
       @prev2 = prev2
       @layer = layer
     end
+
+    def backward(dy)
+      dy1, dy2 =* @layer.backward(dy)
+      @prev1&.backward(dy1)
+      @prev2&.backward(dy2)
+    end
   end
 end

data/lib/dnn/core/losses.rb

@@ -2,25 +2,37 @@ module DNN
   module Losses
 
     class Loss
-      def forward(y, t, layers)
+      def loss(y, t, layers = nil)
         unless y.shape == t.shape
           raise DNN_ShapeError.new("The shape of y does not match the t shape. y shape is #{y.shape}, but t shape is #{t.shape}.")
         end
-        loss_value = forward_loss(y, t)
-        regularizers = layers.select { |layer| layer.is_a?(Layers::Connection) }
-                             .map(&:regularizers).flatten
+        loss_value = forward(y, t)
+        loss_value += regularizers_forward(layers) if layers
+        loss_value
+      end
+
+      def forward(y, t)
+        raise NotImplementedError.new("Class '#{self.class.name}' has implement method 'forward'")
+      end
 
+      def backward(y, t)
+        raise NotImplementedError.new("Class '#{self.class.name}' has implement method 'backward'")
+      end
+
+      def regularizers_forward(layers)
+        loss_value = 0
+        regularizers = layers.select { |layer| layer.respond_to?(:regularizers) }
+                             .map(&:regularizers).flatten
         regularizers.each do |regularizer|
           loss_value = regularizer.forward(loss_value)
         end
         loss_value
       end
 
-      def backward(t, layers)
+      def regularizers_backward(layers)
         layers.select { |layer| layer.respond_to?(:regularizers) }.each do |layer|
           layer.regularizers.each(&:backward)
         end
-        backward_loss(t)
       end
 
       def to_hash(merge_hash = nil)
@@ -28,44 +40,28 @@ module DNN
         hash.merge!(merge_hash) if merge_hash
         hash
       end
-
-      private
-
-      def forward_loss(y, t)
-        raise NotImplementedError.new("Class '#{self.class.name}' has implement method 'forward_loss'")
-      end
-
-      def backward_loss(t)
-        raise NotImplementedError.new("Class '#{self.class.name}' has implement method 'backward_loss'")
-      end
     end
 
     class MeanSquaredError < Loss
-      private
-
-      def forward_loss(y, t)
-        @y = y
+      def forward(y, t)
         batch_size = t.shape[0]
         0.5 * ((y - t) ** 2).sum / batch_size
       end
 
-      def backward_loss(t)
-        @y - t
+      def backward(y, t)
+        y - t
       end
     end
 
 
     class MeanAbsoluteError < Loss
-      private
-
-      def forward_loss(y, t)
-        @y = y
+      def forward(y, t)
         batch_size = t.shape[0]
         (y - t).abs.sum / batch_size
       end
 
-      def backward_loss(t)
-        dy = @y - t
+      def backward(y, t)
+        dy = y - t
         dy[dy >= 0] = 1
         dy[dy < 0] = -1
         dy
@@ -74,14 +70,12 @@ module DNN
 
 
     class Hinge < Loss
-      private
-
-      def forward_loss(y, t)
+      def forward(y, t)
         @a = 1 - y * t
         Xumo::SFloat.maximum(0, @a)
       end
 
-      def backward_loss(t)
+      def backward(y, t)
         a = Xumo::SFloat.ones(*@a.shape)
         a[@a <= 0] = 0
         a * -t
@@ -90,16 +84,13 @@ module DNN
 
 
     class HuberLoss < Loss
-      private
-
-      def forward_loss(y, t)
-        @y = y
-        loss_l1_value = loss_l1(t)
-        @loss_value = loss_l1_value > 1 ? loss_l1_value : loss_l2(t)
+      def forward(y, t)
+        loss_l1_value = loss_l1(y, t)
+        @loss_value = loss_l1_value > 1 ? loss_l1_value : loss_l2(y, t)
       end
 
-      def backward_loss(t)
-        dy = @y - t
+      def backward(y, t)
+        dy = y - t
         if @loss_value > 1
           dy[dy >= 0] = 1
           dy[dy < 0] = -1
@@ -107,14 +98,16 @@ module DNN
         dy
       end
 
-      def loss_l1(t)
+      private
+
+      def loss_l1(y, t)
         batch_size = t.shape[0]
-        (@y - t).abs.sum / batch_size
+        (y - t).abs.sum / batch_size
       end
 
-      def loss_l2(t)
+      def loss_l2(y, t)
         batch_size = t.shape[0]
-        0.5 * ((@y - t) ** 2).sum / batch_size
+        0.5 * ((y - t) ** 2).sum / batch_size
       end
     end
 
@@ -135,20 +128,18 @@ module DNN
         @eps = eps
       end
 
-      def to_hash
-        super(eps: @eps)
+      def forward(y, t)
+        @x = SoftmaxCrossEntropy.softmax(y)
+        batch_size = t.shape[0]
+        -(t * Xumo::NMath.log(@x + @eps)).sum / batch_size
       end
 
-      private
-
-      def forward_loss(y, t)
-        @y = SoftmaxCrossEntropy.softmax(y)
-        batch_size = t.shape[0]
-        -(t * Xumo::NMath.log(@y + @eps)).sum / batch_size
+      def backward(y, t)
+        @x - t
       end
 
-      def backward_loss(t)
-        @y - t
+      def to_hash
+        super(eps: @eps)
       end
     end
 
@@ -165,19 +156,17 @@ module DNN
         @eps = eps
       end
 
-      def to_hash
-        super(eps: @eps)
+      def forward(y, t)
+        @x = Activations::Sigmoid.new.forward(y)
+        -(t * Xumo::NMath.log(@x) + (1 - t) * Xumo::NMath.log(1 - @x))
       end
 
-      private
-
-      def forward_loss(y, t)
-        @y = Activations::Sigmoid.new.forward(y)
-        -(t * Xumo::NMath.log(@y) + (1 - t) * Xumo::NMath.log(1 - @y))
+      def backward(y, t)
+        @x - t
       end
 
-      def backward_loss(t)
-        @y - t
+      def to_hash
+        super(eps: @eps)
       end
     end