ruby-dnn 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a74b3daebe0908a73f01f96bc9a0ed43ece1a6fdeefeac9eb4b4083234f0dc34
-  data.tar.gz: db3c9347d78d0cf3df7558b5cf728cfe05ee6c3bb074737ead4e1d81f9ee0411
+  metadata.gz: 4644c4f76c548fe20e899150fbbed0d445334afa428c8119458d4c90e0bf6afc
+  data.tar.gz: c0ea6b81a390bc06925695663d01f0b235a4e6915a4d4c4e901f22c51217d43a
 SHA512:
-  metadata.gz: f52aa63135790f941d0193a31f120f3b2356132e9c1b1936de418e0a37abd91331f59a4d0d5c1c6918310f90ad30b0d24d7d7e873deb48576abf57db0c0055a2
-  data.tar.gz: fbd915978ac62794b572127caeadba92beac7d8752b6fbe97d55b8f767d5c4b996eac7c7e5da0d50e160cc7c860f4bf14e172e62723c685fdfcaff0f31324017
+  metadata.gz: 282164d11e647a23b86a775cb563a746995cbf4dcc66e10e10ce50706c14ae91e6c6e5579e8ace064554a57e749d1ebc5f617091316e9cd11e05fdc3667e2851
+  data.tar.gz: 2fdd20a6bd776c84ce2bd6d5a49c12003ae20c64218db3b1ba504106d34d08caa55ece05253b32140dd79e2d89f68e33d12348e6c3c2efede7a1d1e1b2ce17c2

data/API-Reference.ja.md

@@ -2,7 +2,7 @@
 ruby-dnnのAPIリファレンスです。このリファレンスでは、APIを利用するうえで必要となるクラスとメソッドしか記載していません。
 そのため、プログラムの詳細が必要な場合は、ソースコードを参照してください。
 
-最終更新バージョン:0.4.2
+最終更新バージョン:0.5.0
 
 # module DNN
 ruby-dnnの名前空間をなすモジュールです。
@@ -121,7 +121,7 @@ epoch_proc
 ### return
 なし。
 
-## def train_on_batch
+## def train_on_batch(x, y, batch_size, &batch_proc)
 入力されたバッチデータをもとに、一度だけ学習を行います。
 ### arguments
 * SFloat x
@@ -485,7 +485,7 @@ Float alpha
 出力値が負のときの傾き。
 
 
-# class IdentityWithLoss < OutputLayer
+# class IdentityMSE < OutputLayer
 恒等関数と二乗誤差関数を合わせた出力層のレイヤーです。
 
 

data/lib/dnn.rb

@@ -11,6 +11,7 @@ require "dnn/core/error"
 require "dnn/core/model"
 require "dnn/core/initializers"
 require "dnn/core/layers"
+require "dnn/core/cnn_layers"
 require "dnn/core/activations"
 require "dnn/core/optimizers"
 require "dnn/core/util"

data/lib/dnn/core/activations.rb

@@ -75,7 +75,7 @@ module DNN
     end
 
 
-    class IdentityWithLoss < OutputLayer
+    class IdentityMSE < OutputLayer
       def forward(x)
         @out = x
       end

data/lib/dnn/core/cnn_layers.rb

@@ -0,0 +1,263 @@
+module DNN
+  module Layers
+    #This module is used for convolution.
+    module Conv2DModule
+      private
+
+      def im2col(img, out_h, out_w, fil_h, fil_w, strides)
+        bsize = img.shape[0]
+        ch = img.shape[3]
+        col = SFloat.zeros(bsize, ch, fil_h, fil_w, out_h, out_w)
+        img = img.transpose(0, 3, 1, 2)
+        (0...fil_h).each do |i|
+          i_range = (i...(i + strides[0] * out_h)).step(strides[0]).to_a
+          (0...fil_w).each do |j|
+            j_range = (j...(j + strides[1] * out_w)).step(strides[1]).to_a
+            col[true, true, i, j, true, true] = img[true, true, i_range, j_range]
+          end
+        end
+        col.transpose(0, 4, 5, 2, 3, 1).reshape(bsize * out_h * out_w, fil_h * fil_w * ch)
+      end
+
+      def col2im(col, img_shape, out_h, out_w, fil_h, fil_w, strides)
+        bsize, img_h, img_w, ch = img_shape
+        col = col.reshape(bsize, out_h, out_w, fil_h, fil_w, ch).transpose(0, 5, 3, 4, 1, 2)
+        img = SFloat.zeros(bsize, ch, img_h, img_w)
+        (0...fil_h).each do |i|
+          i_range = (i...(i + strides[0] * out_h)).step(strides[0]).to_a
+          (0...fil_w).each do |j|
+            j_range = (j...(j + strides[1] * out_w)).step(strides[1]).to_a
+            img[true, true, i_range, j_range] += col[true, true, i, j, true, true]
+          end
+        end
+        img.transpose(0, 2, 3, 1)
+      end
+
+      def padding(img, pad)
+        bsize, img_h, img_w, ch = img.shape
+        img2 = SFloat.zeros(bsize, img_h + pad[0], img_w + pad[1], ch)
+        i_begin = pad[0] / 2
+        i_end = i_begin + img_h
+        j_begin = pad[1] / 2
+        j_end = j_begin + img_w
+        img2[true, i_begin...i_end, j_begin...j_end, true] = img
+        img2
+      end
+
+      def back_padding(img, pad)
+        i_begin = pad[0] / 2
+        i_end = img.shape[1] - (pad[0] / 2.0).round
+        j_begin = pad[1] / 2
+        j_end = img.shape[2] - (pad[1] / 2.0).round
+        img[true, i_begin...i_end, j_begin...j_end, true]
+      end
+
+      def out_size(prev_h, prev_w, fil_h, fil_w, strides)
+        out_h = (prev_h - fil_h) / strides[0] + 1
+        out_w = (prev_w - fil_w) / strides[1] + 1
+        [out_h, out_w]
+      end
+    end
+    
+    
+    class Conv2D < HasParamLayer
+      include Initializers
+      include Conv2DModule
+
+      attr_reader :num_filters
+      attr_reader :filter_size
+      attr_reader :strides
+      attr_reader :weight_decay
+    
+      def initialize(num_filters, filter_size,
+                     weight_initializer: nil,
+                     bias_initializer: nil,
+                     strides: 1,
+                     padding: false,
+                     weight_decay: 0)
+        super()
+        @num_filters = num_filters
+        @filter_size = filter_size.is_a?(Integer) ? [filter_size, filter_size] : filter_size
+        @weight_initializer = (weight_initializer || RandomNormal.new)
+        @bias_initializer = (bias_initializer || Zeros.new)
+        @strides = strides.is_a?(Integer) ? [strides, strides] : strides
+        @padding = padding
+        @weight_decay = weight_decay
+      end
+
+      def self.load_hash(hash)
+        Conv2D.new(hash[:num_filters], hash[:filter_size],
+                   weight_initializer: Util.load_hash(hash[:weight_initializer]),
+                   bias_initializer: Util.load_hash(hash[:bias_initializer]),
+                   strides: hash[:strides],
+                   padding: hash[:padding],
+                   weight_decay: hash[:weight_decay])
+      end
+
+      def build(model)
+        super
+        prev_h, prev_w = prev_layer.shape[0..1]
+        @out_size = out_size(prev_h, prev_w, *@filter_size, @strides)
+        out_w, out_h = @out_size
+        if @padding
+          @pad = [prev_h - out_h, prev_w - out_w]
+          @out_size = [prev_h, prev_w]
+        end
+      end
+
+      def forward(x)
+        x = padding(x, @pad) if @padding
+        @x_shape = x.shape
+        @col = im2col(x, *@out_size, *@filter_size, @strides)
+        out = @col.dot(@params[:weight])
+        out.reshape(x.shape[0], *@out_size, out.shape[3])
+      end
+
+      def backward(dout)
+        dout = dout.reshape(dout.shape[0..2].reduce(:*), dout.shape[3])
+        @grads[:weight] = @col.transpose.dot(dout)
+        if @weight_decay > 0
+          dridge = @weight_decay * @params[:weight]
+          @grads[:weight] += dridge
+        end
+        @grads[:bias] = dout.sum(0)
+        dcol = dout.dot(@params[:weight].transpose)
+        dx = col2im(dcol, @x_shape, *@out_size, *@filter_size, @strides)
+        @padding ? back_padding(dx, @pad) : dx
+      end
+
+      def shape
+        [*@out_size, @num_filters]
+      end
+
+      def to_hash
+        super({num_filters: @num_filters,
+               filter_size: @filter_size,
+               weight_initializer: @weight_initializer.to_hash,
+               bias_initializer: @bias_initializer.to_hash,
+               strides: @strides,
+               padding: @padding,
+               weight_decay: @weight_decay})
+      end
+    
+      private
+    
+      def init_params
+        num_prev_filter = prev_layer.shape[2]
+        @params[:weight] = SFloat.new(num_prev_filter * @filter_size.reduce(:*), @num_filters)
+        @params[:bias] = SFloat.new(@num_filters)
+        @weight_initializer.init_param(self, :weight)
+        @bias_initializer.init_param(self, :bias)
+      end
+    end
+    
+    
+    class MaxPool2D < Layer
+      include Conv2DModule
+
+      attr_reader :pool_size
+      attr_reader :strides
+
+      def self.load_hash(hash)
+        MaxPool2D.new(hash[:pool_size], strides: hash[:strides], padding: hash[:padding])
+      end
+
+      def initialize(pool_size, strides: nil, padding: false)
+        super()
+        @pool_size = pool_size.is_a?(Integer) ? [pool_size, pool_size] : pool_size
+        @strides = if strides
+          strides.is_a?(Integer) ? [strides, strides] : strides
+        else
+          @pool_size.clone
+        end
+        @padding = padding
+      end
+
+      def build(model)
+        super
+        prev_w, prev_h = prev_layer.shape[0..1]
+        @num_channel = prev_layer.shape[2]
+        @out_size = out_size(prev_h, prev_w, *@pool_size, @strides)
+        out_w, out_h = @out_size
+        if @padding
+          @pad = [prev_h - out_h, prev_w - out_w]
+          @out_size = [prev_h, prev_w]
+        end
+      end
+
+      def forward(x)
+        x = padding(x, @pad) if @padding
+        @x_shape = x.shape
+        col = im2col(x, *@out_size, *@pool_size, @strides)
+        col = col.reshape(x.shape[0] * @out_size.reduce(:*) * x.shape[3], @pool_size.reduce(:*))
+        @max_index = col.max_index(1)
+        col.max(1).reshape(x.shape[0], *@out_size, x.shape[3])
+      end
+
+      def backward(dout)
+        dmax = SFloat.zeros(dout.size * @pool_size.reduce(:*))
+        dmax[@max_index] = dout.flatten
+        dcol = dmax.reshape(dout.shape[0..2].reduce(:*), dout.shape[3] * @pool_size.reduce(:*))
+        dx = col2im(dcol, @x_shape, *@out_size, *@pool_size, @strides)
+        @padding ? back_padding(dx, @pad) : dx
+      end
+
+      def shape
+        [*@out_size, @num_channel]
+      end
+
+      def to_hash
+        super({pool_width: @pool_width,
+               pool_height: @pool_height,
+               strides: @strides,
+               padding: @padding})
+      end
+    end
+
+
+    class UnPool2D < Layer
+      attr_reader :unpool_size
+
+      def initialize(unpool_size)
+        super()
+        @unpool_size = unpool_size.is_a?(Integer) ? [unpool_size, unpool_size] : unpool_size
+      end
+
+      def self.load_hash(hash)
+        UnPool2D.new(hash[:unpool_size])
+      end
+
+      def build(model)
+        super
+        prev_h, prev_w = prev_layer.shape[0..1]
+        unpool_h, unpool_w = @unpool_size
+        out_h = prev_h * unpool_h
+        out_w = prev_w * unpool_w
+        @out_size = [out_h, out_w]
+        @num_channel = prev_layer.shape[2]
+      end
+
+      def forward(x)
+        @x_shape = x.shape
+        unpool_h, unpool_w = @unpool_size
+        x2 = SFloat.zeros(x.shape[0], x.shape[1], unpool_h, x.shape[2], unpool_w, @num_channel)
+        x2[true, true, 0, true, 0, true] = x
+        x2.reshape(x.shape[0], *@out_size, x.shape[3])
+      end
+
+      def backward(dout)
+        unpool_h, unpool_w = @unpool_size
+        dout = dout.reshape(dout.shape[0], @x_shape[0], unpool_h, @x_shape[1], unpool_w, @num_channel)
+        dout[true, true, 0, true, 0, true].clone
+      end
+
+      def shape
+        [@out_width, @out_height, @num_channel]
+      end
+
+      def to_hash
+        super({unpool_size: @unpool_size})
+      end
+    end
+  end
+end

data/lib/dnn/core/error.rb

@@ -4,10 +4,4 @@ module DNN
   class DNN_TypeError < DNN_Error; end
 
   class DNN_SharpError < DNN_Error; end
-
-  class DNN_GradUnfairError < DNN_Error
-    def initialize(grad, n_grad)
-      super("gradient is #{grad}, but numerical gradient is #{n_grad}")
-    end
-  end
 end

data/lib/dnn/core/layers.rb

@@ -158,267 +158,6 @@ module DNN
       end
     end
     
-    
-    #This module is used for convolution.
-    module Conv2DModule
-      private
-
-      def im2col(img, out_h, out_w, fil_h, fil_w, strides)
-        bsize = img.shape[0]
-        ch = img.shape[3]
-        col = SFloat.zeros(bsize, ch, fil_h, fil_w, out_h, out_w)
-        img = img.transpose(0, 3, 1, 2)
-        (0...fil_h).each do |i|
-          i_range = (i...(i + strides[0] * out_h)).step(strides[0]).to_a
-          (0...fil_w).each do |j|
-            j_range = (j...(j + strides[1] * out_w)).step(strides[1]).to_a
-            col[true, true, i, j, true, true] = img[true, true, i_range, j_range]
-          end
-        end
-        col.transpose(0, 4, 5, 2, 3, 1).reshape(bsize * out_h * out_w, fil_h * fil_w * ch)
-      end
-
-      def col2im(col, img_shape, out_h, out_w, fil_h, fil_w, strides)
-        bsize, img_h, img_w, ch = img_shape
-        col = col.reshape(bsize, out_h, out_w, fil_h, fil_w, ch).transpose(0, 5, 3, 4, 1, 2)
-        img = SFloat.zeros(bsize, ch, img_h, img_w)
-        (0...fil_h).each do |i|
-          i_range = (i...(i + strides[0] * out_h)).step(strides[0]).to_a
-          (0...fil_w).each do |j|
-            j_range = (j...(j + strides[1] * out_w)).step(strides[1]).to_a
-            img[true, true, i_range, j_range] += col[true, true, i, j, true, true]
-          end
-        end
-        img.transpose(0, 2, 3, 1)
-      end
-
-      def padding(img, pad)
-        bsize, img_h, img_w, ch = img.shape
-        img2 = SFloat.zeros(bsize, img_h + pad[0], img_w + pad[1], ch)
-        i_begin = pad[0] / 2
-        i_end = i_begin + img_h
-        j_begin = pad[1] / 2
-        j_end = j_begin + img_w
-        img2[true, i_begin...i_end, j_begin...j_end, true] = img
-        img2
-      end
-
-      def back_padding(img, pad)
-        i_begin = pad[0] / 2
-        i_end = img.shape[1] - (pad[0] / 2.0).round
-        j_begin = pad[1] / 2
-        j_end = img.shape[2] - (pad[1] / 2.0).round
-        img[true, i_begin...i_end, j_begin...j_end, true]
-      end
-
-      def out_size(prev_h, prev_w, fil_h, fil_w, strides)
-        out_h = (prev_h - fil_h) / strides[0] + 1
-        out_w = (prev_w - fil_w) / strides[1] + 1
-        [out_h, out_w]
-      end
-    end
-    
-    
-    class Conv2D < HasParamLayer
-      include Initializers
-      include Conv2DModule
-
-      attr_reader :num_filters
-      attr_reader :filter_size
-      attr_reader :strides
-      attr_reader :weight_decay
-    
-      def initialize(num_filters, filter_size,
-                     weight_initializer: nil,
-                     bias_initializer: nil,
-                     strides: 1,
-                     padding: false,
-                     weight_decay: 0)
-        super()
-        @num_filters = num_filters
-        @filter_size = filter_size.is_a?(Integer) ? [filter_size, filter_size] : filter_size
-        @weight_initializer = (weight_initializer || RandomNormal.new)
-        @bias_initializer = (bias_initializer || Zeros.new)
-        @strides = strides.is_a?(Integer) ? [strides, strides] : strides
-        @padding = padding
-        @weight_decay = weight_decay
-      end
-
-      def self.load_hash(hash)
-        Conv2D.new(hash[:num_filters], hash[:filter_size],
-                   weight_initializer: Util.load_hash(hash[:weight_initializer]),
-                   bias_initializer: Util.load_hash(hash[:bias_initializer]),
-                   strides: hash[:strides],
-                   padding: hash[:padding],
-                   weight_decay: hash[:weight_decay])
-      end
-
-      def build(model)
-        super
-        prev_h, prev_w = prev_layer.shape[0..1]
-        @out_size = out_size(prev_h, prev_w, *@filter_size, @strides)
-        out_w, out_h = @out_size
-        if @padding
-          @pad = [prev_h - out_h, prev_w - out_w]
-          @out_size = [prev_h, prev_w]
-        end
-      end
-
-      def forward(x)
-        x = padding(x, @pad) if @padding
-        @x_shape = x.shape
-        @col = im2col(x, *@out_size, *@filter_size, @strides)
-        out = @col.dot(@params[:weight])
-        out.reshape(x.shape[0], *@out_size, out.shape[3])
-      end
-
-      def backward(dout)
-        dout = dout.reshape(dout.shape[0..2].reduce(:*), dout.shape[3])
-        @grads[:weight] = @col.transpose.dot(dout)
-        if @weight_decay > 0
-          dridge = @weight_decay * @params[:weight]
-          @grads[:weight] += dridge
-        end
-        @grads[:bias] = dout.sum(0)
-        dcol = dout.dot(@params[:weight].transpose)
-        dx = col2im(dcol, @x_shape, *@out_size, *@filter_size, @strides)
-        @padding ? back_padding(dx, @pad) : dx
-      end
-
-      def shape
-        [*@out_size, @num_filters]
-      end
-
-      def to_hash
-        super({num_filters: @num_filters,
-               filter_size: @filter_size,
-               weight_initializer: @weight_initializer.to_hash,
-               bias_initializer: @bias_initializer.to_hash,
-               strides: @strides,
-               padding: @padding,
-               weight_decay: @weight_decay})
-      end
-    
-      private
-    
-      def init_params
-        num_prev_filter = prev_layer.shape[2]
-        @params[:weight] = SFloat.new(num_prev_filter * @filter_size.reduce(:*), @num_filters)
-        @params[:bias] = SFloat.new(@num_filters)
-        @weight_initializer.init_param(self, :weight)
-        @bias_initializer.init_param(self, :bias)
-      end
-    end
-    
-    
-    class MaxPool2D < Layer
-      include Conv2DModule
-
-      attr_reader :pool_size
-      attr_reader :strides
-
-      def self.load_hash(hash)
-        MaxPool2D.new(hash[:pool_size], strides: hash[:strides], padding: hash[:padding])
-      end
-
-      def initialize(pool_size, strides: nil, padding: false)
-        super()
-        @pool_size = pool_size.is_a?(Integer) ? [pool_size, pool_size] : pool_size
-        @strides = if strides
-          strides.is_a?(Integer) ? [strides, strides] : strides
-        else
-          @pool_size.clone
-        end
-        @padding = padding
-      end
-
-      def build(model)
-        super
-        prev_w, prev_h = prev_layer.shape[0..1]
-        @num_channel = prev_layer.shape[2]
-        @out_size = out_size(prev_h, prev_w, *@pool_size, @strides)
-        out_w, out_h = @out_size
-        if @padding
-          @pad = [prev_h - out_h, prev_w - out_w]
-          @out_size = [prev_h, prev_w]
-        end
-      end
-
-      def forward(x)
-        x = padding(x, @pad) if @padding
-        @x_shape = x.shape
-        col = im2col(x, *@out_size, *@pool_size, @strides)
-        col = col.reshape(x.shape[0] * @out_size.reduce(:*) * x.shape[3], @pool_size.reduce(:*))
-        @max_index = col.max_index(1)
-        col.max(1).reshape(x.shape[0], *@out_size, x.shape[3])
-      end
-
-      def backward(dout)
-        dmax = SFloat.zeros(dout.size * @pool_size.reduce(:*))
-        dmax[@max_index] = dout.flatten
-        dcol = dmax.reshape(dout.shape[0..2].reduce(:*), dout.shape[3] * @pool_size.reduce(:*))
-        dx = col2im(dcol, @x_shape, *@out_size, *@pool_size, @strides)
-        @padding ? back_padding(dx, @pad) : dx
-      end
-
-      def shape
-        [*@out_size, @num_channel]
-      end
-
-      def to_hash
-        super({pool_width: @pool_width,
-               pool_height: @pool_height,
-               strides: @strides,
-               padding: @padding})
-      end
-    end
-
-
-    class UnPool2D < Layer
-      attr_reader :unpool_size
-
-      def initialize(unpool_size)
-        super()
-        @unpool_size = unpool_size.is_a?(Integer) ? [unpool_size, unpool_size] : unpool_size
-      end
-
-      def self.load_hash(hash)
-        UnPool2D.new(hash[:unpool_size])
-      end
-
-      def build(model)
-        super
-        prev_h, prev_w = prev_layer.shape[0..1]
-        unpool_h, unpool_w = @unpool_size
-        out_h = prev_h * unpool_h
-        out_w = prev_w * unpool_w
-        @out_size = [out_h, out_w]
-        @num_channel = prev_layer.shape[2]
-      end
-
-      def forward(x)
-        @x_shape = x.shape
-        unpool_h, unpool_w = @unpool_size
-        x2 = SFloat.zeros(x.shape[0], x.shape[1], unpool_h, x.shape[2], unpool_w, @num_channel)
-        x2[true, true, 0, true, 0, true] = x
-        x2.reshape(x.shape[0], *@out_size, x.shape[3])
-      end
-
-      def backward(dout)
-        unpool_h, unpool_w = @unpool_size
-        dout = dout.reshape(dout.shape[0], @x_shape[0], unpool_h, @x_shape[1], unpool_w, @num_channel)
-        dout[true, true, 0, true, 0, true].clone
-      end
-
-      def shape
-        [@out_width, @out_height, @num_channel]
-      end
-
-      def to_hash
-        super({unpool_size: @unpool_size})
-      end
-    end
-    
 
     class Flatten < Layer
       def forward(x)

data/lib/dnn/core/model.rb

@@ -8,13 +8,6 @@ module DNN
     attr_accessor :layers
     attr_reader :optimizer
     attr_reader :batch_size
-  
-    def initialize
-      @layers = []
-      @optimizer = nil
-      @batch_size = nil
-      @compiled = false
-    end
 
     def self.load(file_name)
       Marshal.load(File.binread(file_name))
@@ -27,6 +20,14 @@ module DNN
       model.compile(Util.load_hash(hash[:optimizer]))
       model
     end
+  
+    def initialize
+      @layers = []
+      @optimizer = nil
+      @batch_size = nil
+      @training = false
+      @compiled = false
+    end
 
     def load_json_params(json_str)
       has_param_layers_params = JSON.parse(json_str, symbolize_names: true)
@@ -128,6 +129,47 @@ module DNN
         epoch_proc.call(epoch) if epoch_proc
       end
     end
+
+    def train(x, y, epochs,
+              batch_size: 1,
+              test: nil,
+              verbose: true,
+              batch_proc: nil,
+              &epoch_proc)
+      @batch_size = batch_size
+      num_train_data = x.shape[0]
+      (1..epochs).each do |epoch|
+        puts "【 epoch #{epoch}/#{epochs} 】" if verbose
+        (num_train_data.to_f / @batch_size).ceil.times do |index|
+          x_batch, y_batch = Util.get_minibatch(x, y, @batch_size)
+          loss = train_on_batch(x_batch, y_batch, @batch_size, &batch_proc)
+          if loss.nan?
+            puts "\nloss is nan" if verbose
+            return
+          end
+          num_trained_data = (index + 1) * batch_size
+          num_trained_data = num_trained_data > num_train_data ? num_train_data : num_trained_data
+          log = "\r"
+          40.times do |i|
+            if i < num_trained_data * 40 / num_train_data
+              log << "="
+            elsif i == num_trained_data * 40 / num_train_data
+              log << ">"
+            else
+              log << "_"
+            end
+          end
+          log << "  #{num_trained_data}/#{num_train_data} loss: #{sprintf('%.8f', loss)}"
+          print log if verbose
+        end
+        if verbose && test
+          acc = accurate(test[0], test[1], batch_size,&batch_proc)
+          print "  accurate: #{acc}"
+        end
+        puts "" if verbose
+        epoch_proc.call(epoch) if epoch_proc
+      end
+    end
   
     def train_on_batch(x, y, batch_size, &batch_proc)
       @batch_size = batch_size

data/lib/dnn/version.rb

@@ -1,3 +1,3 @@
 module DNN
-  VERSION = "0.4.4"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dnn
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: ruby
 authors:
 - unagiootoro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-25 00:00:00.000000000 Z
+date: 2018-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -106,6 +106,7 @@ files:
 - examples/xor_example.rb
 - lib/dnn.rb
 - lib/dnn/core/activations.rb
+- lib/dnn/core/cnn_layers.rb
 - lib/dnn/core/error.rb
 - lib/dnn/core/initializers.rb
 - lib/dnn/core/layers.rb