ruby-dnn 0.10.4 → 0.12.4

data/examples/mnist_lstm_example.rb

@@ -7,7 +7,7 @@ include DNN::Layers
 include DNN::Activations
 include DNN::Optimizers
 include DNN::Losses
-Model = DNN::Model
+include DNN::Models
 MNIST = DNN::MNIST
 
 x_train, y_train = MNIST.load_train
@@ -22,7 +22,7 @@ x_test /= 255
 y_train = DNN::Utils.to_categorical(y_train, 10, Numo::SFloat)
 y_test = DNN::Utils.to_categorical(y_test, 10, Numo::SFloat)
 
-model = Model.new
+model = Sequential.new
 
 model << InputLayer.new([28, 28])
 
@@ -31,6 +31,6 @@ model << LSTM.new(200, return_sequences: false)
 
 model << Dense.new(10)
 
-model.compile(Adam.new, SoftmaxCrossEntropy.new)
+model.setup(Adam.new, SoftmaxCrossEntropy.new)
 
 model.train(x_train, y_train, 10, batch_size: 100, test: [x_test, y_test])

data/examples/xor_example.rb

@@ -4,21 +4,20 @@ include DNN::Layers
 include DNN::Activations
 include DNN::Optimizers
 include DNN::Losses
-Model = DNN::Model
-Utils = DNN::Utils
+include DNN::Models
 
 x = Numo::SFloat[[0, 0], [1, 0], [0, 1], [1, 1]]
 y = Numo::SFloat[[0], [1], [1], [0]]
 
-model = Model.new
+model = Sequential.new
 
 model << InputLayer.new(2)
 model << Dense.new(16)
 model << ReLU.new
 model << Dense.new(1)
 
-model.compile(SGD.new, SigmoidCrossEntropy.new)
+model.setup(SGD.new, SigmoidCrossEntropy.new)
 
 model.train(x, y, 20000, batch_size: 4, verbose: false)
 
-p Utils.sigmoid(model.predict(x))
+p DNN::Utils.sigmoid(model.predict(x))

data/ext/rb_stb_image/rb_stb_image.c

@@ -3,9 +3,11 @@
 
 #define STB_IMAGE_IMPLEMENTATION
 #define STB_IMAGE_WRITE_IMPLEMENTATION
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
 
 #include "../../third_party/stb_image.h"
 #include "../../third_party/stb_image_write.h"
+#include "../../third_party/stb_image_resize.h"
 
 // STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp);
 static VALUE rb_stbi_load(VALUE self, VALUE rb_filename, VALUE rb_req_comp) {
@@ -94,14 +96,115 @@ static VALUE rb_stbi_write_jpg(VALUE self, VALUE rb_filename, VALUE rb_w, VALUE
   return INT2FIX(result);
 }
 
+// STBIRDEF int stbir_resize_uint8(     const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+//                                            unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+//                                      int num_channels);
+static VALUE rb_stbir_resize_uint8(VALUE self, VALUE rb_input_pixels, VALUE rb_input_w, VALUE rb_input_h, VALUE rb_input_stride_in_bytes,
+                                   VALUE rb_output_w, VALUE rb_output_h, VALUE rb_output_stride_in_bytes, VALUE rb_num_channels) {
+  uint8_t* input_pixels = (uint8_t*)StringValuePtr(rb_input_pixels);
+  int32_t input_w = FIX2INT(rb_input_w);
+  int32_t input_h = FIX2INT(rb_input_h);
+  int32_t input_stride_in_bytes = FIX2INT(rb_input_stride_in_bytes);
+  int32_t output_w = FIX2INT(rb_output_w);
+  int32_t output_h = FIX2INT(rb_output_h);
+  int32_t output_stride_in_bytes = FIX2INT(rb_output_stride_in_bytes);
+  int32_t num_channels = FIX2INT(rb_num_channels);
+  uint8_t* output_pixels;
+  VALUE rb_output_pixels;
+  int32_t result;
+  const int32_t output_size = output_h * output_w * num_channels;
+
+  output_pixels = (uint8_t*)malloc(output_size);
+  result = stbir_resize_uint8(input_pixels, input_w, input_h, input_stride_in_bytes,
+                              output_pixels, output_w, output_h, output_stride_in_bytes, num_channels);
+  rb_output_pixels = rb_str_new((char*)output_pixels, output_size);
+  free(output_pixels);
+  return rb_ary_new3(2, rb_output_pixels, INT2FIX(result));
+}
+
+// STBIRDEF int stbir_resize_uint8_srgb(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+//                                            unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+//                                      int num_channels, int alpha_channel, int flags);
+static VALUE rb_stbir_resize_uint8_srgb(VALUE self, VALUE rb_input_pixels, VALUE rb_input_w, VALUE rb_input_h, VALUE rb_input_stride_in_bytes,
+                                   VALUE rb_output_w, VALUE rb_output_h, VALUE rb_output_stride_in_bytes, VALUE rb_num_channels,
+                                   VALUE rb_alpha_channel, VALUE rb_flags) {
+  uint8_t* input_pixels = (uint8_t*)StringValuePtr(rb_input_pixels);
+  int32_t input_w = FIX2INT(rb_input_w);
+  int32_t input_h = FIX2INT(rb_input_h);
+  int32_t input_stride_in_bytes = FIX2INT(rb_input_stride_in_bytes);
+  int32_t output_w = FIX2INT(rb_output_w);
+  int32_t output_h = FIX2INT(rb_output_h);
+  int32_t output_stride_in_bytes = FIX2INT(rb_output_stride_in_bytes);
+  int32_t num_channels = FIX2INT(rb_num_channels);
+  int32_t alpha_channel = FIX2INT(rb_alpha_channel);
+  int32_t flags = FIX2INT(rb_flags);
+  uint8_t* output_pixels;
+  VALUE rb_output_pixels;
+  int32_t result;
+  const int32_t output_size = output_h * output_w * num_channels;
+
+  output_pixels = (uint8_t*)malloc(output_size);
+  result = stbir_resize_uint8_srgb(input_pixels, input_w, input_h, input_stride_in_bytes,
+                                   output_pixels, output_w, output_h, output_stride_in_bytes,
+                                   num_channels, alpha_channel, flags);
+  rb_output_pixels = rb_str_new((char*)output_pixels, output_size);
+  free(output_pixels);
+  return rb_ary_new3(2, rb_output_pixels, INT2FIX(result));
+}
+
+// STBIRDEF int stbir_resize_uint8_srgb_edgemode(const unsigned char *input_pixels , int input_w , int input_h , int input_stride_in_bytes,
+//                                                    unsigned char *output_pixels, int output_w, int output_h, int output_stride_in_bytes,
+//                                              int num_channels, int alpha_channel, int flags,
+//                                              stbir_edge edge_wrap_mode);
+static VALUE rb_stbir_resize_uint8_srgb_edgemode(VALUE self, VALUE rb_input_pixels, VALUE rb_input_w, VALUE rb_input_h, VALUE rb_input_stride_in_bytes,
+                                   VALUE rb_output_w, VALUE rb_output_h, VALUE rb_output_stride_in_bytes, VALUE rb_num_channels,
+                                   VALUE rb_alpha_channel, VALUE rb_flags, VALUE rb_edge_wrap_mode) {
+  uint8_t* input_pixels = (uint8_t*)StringValuePtr(rb_input_pixels);
+  int32_t input_w = FIX2INT(rb_input_w);
+  int32_t input_h = FIX2INT(rb_input_h);
+  int32_t input_stride_in_bytes = FIX2INT(rb_input_stride_in_bytes);
+  int32_t output_w = FIX2INT(rb_output_w);
+  int32_t output_h = FIX2INT(rb_output_h);
+  int32_t output_stride_in_bytes = FIX2INT(rb_output_stride_in_bytes);
+  int32_t num_channels = FIX2INT(rb_num_channels);
+  int32_t alpha_channel = FIX2INT(rb_alpha_channel);
+  int32_t flags = FIX2INT(rb_flags);
+  stbir_edge edge_wrap_mode = (stbir_edge)FIX2INT(rb_edge_wrap_mode);
+  uint8_t* output_pixels;
+  VALUE rb_output_pixels;
+  int32_t result;
+  const int32_t output_size = output_h * output_w * num_channels;
+
+  output_pixels = (uint8_t*)malloc(output_size);
+  result = stbir_resize_uint8_srgb_edgemode(input_pixels, input_w, input_h, input_stride_in_bytes,
+                                            output_pixels, output_w, output_h, output_stride_in_bytes,
+                                            num_channels, alpha_channel, flags, edge_wrap_mode);
+  rb_output_pixels = rb_str_new((char*)output_pixels, output_size);
+  free(output_pixels);
+  return rb_ary_new3(2, rb_output_pixels, INT2FIX(result));
+}
+
 void Init_rb_stb_image() {
   VALUE rb_dnn = rb_define_module("DNN");
   VALUE rb_stb = rb_define_module_under(rb_dnn, "Stb");
 
+  rb_define_const(rb_stb, "STBIR_ALPHA_CHANNEL_NONE", INT2FIX(STBIR_ALPHA_CHANNEL_NONE));
+
+  rb_define_const(rb_stb, "STBIR_FLAG_ALPHA_PREMULTIPLIED", INT2FIX(STBIR_FLAG_ALPHA_PREMULTIPLIED));
+  rb_define_const(rb_stb, "STBIR_FLAG_ALPHA_USES_COLORSPACE", INT2FIX(STBIR_FLAG_ALPHA_USES_COLORSPACE));
+
+  rb_define_const(rb_stb, "STBIR_EDGE_CLAMP", INT2FIX(STBIR_EDGE_CLAMP));
+  rb_define_const(rb_stb, "STBIR_EDGE_REFLECT", INT2FIX(STBIR_EDGE_REFLECT));
+  rb_define_const(rb_stb, "STBIR_EDGE_WRAP", INT2FIX(STBIR_EDGE_WRAP));
+  rb_define_const(rb_stb, "STBIR_EDGE_ZERO", INT2FIX(STBIR_EDGE_ZERO));
+
   rb_define_module_function(rb_stb, "stbi_load", rb_stbi_load, 2);
   rb_define_module_function(rb_stb, "stbi_write_png", rb_stbi_write_png, 6);
   rb_define_module_function(rb_stb, "stbi_write_bmp", rb_stbi_write_bmp, 5);
   rb_define_module_function(rb_stb, "stbi_write_tga", rb_stbi_write_tga, 5);
   rb_define_module_function(rb_stb, "stbi_write_hdr", rb_stbi_write_hdr, 5);
   rb_define_module_function(rb_stb, "stbi_write_jpg", rb_stbi_write_jpg, 6);
+  rb_define_module_function(rb_stb, "stbir_resize_uint8", rb_stbir_resize_uint8, 8);
+  rb_define_module_function(rb_stb, "stbir_resize_uint8_srgb", rb_stbir_resize_uint8_srgb, 10);
+  rb_define_module_function(rb_stb, "stbir_resize_uint8_srgb_edgemode", rb_stbir_resize_uint8_srgb_edgemode, 11);
 }

data/lib/dnn.rb

@@ -1,23 +1,23 @@
-if defined? Cumo
-  Xumo = Cumo
-else
-  require "numo/narray"
-  Xumo = Numo
-end
-
 module DNN
-  NMath = Xumo::NMath
+  if defined? ::Cumo
+    Xumo = ::Cumo
+  else
+    require "numo/narray"
+    Xumo = ::Numo
+  end
 end
 
 require_relative "dnn/version"
 require_relative "dnn/core/error"
-require_relative "dnn/core/model"
+require_relative "dnn/core/models"
 require_relative "dnn/core/param"
-require_relative "dnn/core/dataset"
+require_relative "dnn/core/link"
+require_relative "dnn/core/iterator"
 require_relative "dnn/core/initializers"
 require_relative "dnn/core/layers"
 require_relative "dnn/core/normalizations"
 require_relative "dnn/core/activations"
+require_relative "dnn/core/merge_layers"
 require_relative "dnn/core/losses"
 require_relative "dnn/core/regularizers"
 require_relative "dnn/core/cnn_layers"

data/lib/dnn/cifar10.rb

@@ -16,7 +16,7 @@ module DNN
       cifar10_binary_file_name = __dir__ + "/downloads/" + URL_CIFAR10.match(%r`.+/(.+)`)[1]
       begin
         Zlib::GzipReader.open(cifar10_binary_file_name) do |gz|
-          Archive::Tar::Minitar::unpack(gz, __dir__ + "/downloads")
+          Archive::Tar::Minitar.unpack(gz, __dir__ + "/downloads")
         end
       ensure
         File.unlink(cifar10_binary_file_name)

data/lib/dnn/cifar100.rb

@@ -16,7 +16,7 @@ module DNN
       cifar100_binary_file_name = __dir__ + "/downloads/" + URL_CIFAR100.match(%r`.+/(.+)`)[1]
       begin
         Zlib::GzipReader.open(cifar100_binary_file_name) do |gz|
-          Archive::Tar::Minitar::unpack(gz, __dir__ + "/downloads")
+          Archive::Tar::Minitar.unpack(gz, __dir__ + "/downloads")
         end
       ensure
         File.unlink(cifar100_binary_file_name)

data/lib/dnn/core/activations.rb

@@ -3,9 +3,9 @@ module DNN
 
     class Sigmoid < Layers::Layer
       def forward(x)
-        @y = 1 / (1 + NMath.exp(-x))
+        @y = 1 / (1 + Xumo::NMath.exp(-x))
       end
-    
+
       def backward(dy)
         dy * (1 - @y) * @y
       end
@@ -14,11 +14,11 @@ module DNN
 
     class Tanh < Layers::Layer
       def forward(x)
-        @y = NMath.tanh(x)
+        @y = Xumo::NMath.tanh(x)
       end
-      
+
       def backward(dy)
-        dy * (1 - @y**2)
+        dy * (1 - @y ** 2)
       end
     end
 
@@ -30,7 +30,7 @@ module DNN
       end
 
       def backward(dy)
-        dy * (1 / (1 + @x.abs)**2)
+        dy * (1 / (1 + @x.abs) ** 2)
       end
     end
 
@@ -38,11 +38,11 @@ module DNN
     class Softplus < Layers::Layer
       def forward(x)
         @x = x
-        NMath.log(1 + NMath.exp(x))
+        Xumo::NMath.log(1 + Xumo::NMath.exp(x))
       end
 
       def backward(dy)
-        dy * (1 / (1 + NMath.exp(-@x)))
+        dy * (1 / (1 + Xumo::NMath.exp(-@x)))
       end
     end
 
@@ -50,22 +50,21 @@ module DNN
     class Swish < Layers::Layer
       def forward(x)
         @x = x
-        @y = x * (1 / (1 + NMath.exp(-x)))
+        @y = x * (1 / (1 + Xumo::NMath.exp(-x)))
       end
-    
+
       def backward(dy)
-        dy * (@y + (1 / (1 + NMath.exp(-@x))) * (1 - @y))
+        dy * (@y + (1 / (1 + Xumo::NMath.exp(-@x))) * (1 - @y))
       end
     end
-    
-    
+
+
     class ReLU < Layers::Layer
       def forward(x)
         @x = x
-        x[x < 0] = 0
-        x
+        Xumo::SFloat.maximum(0, x)
       end
-    
+
       def backward(dy)
         dx = Xumo::SFloat.ones(@x.shape)
         dx[@x <= 0] = 0
@@ -75,7 +74,6 @@ module DNN
 
 
     class LeakyReLU < Layers::Layer
-      # @return [Float] Return the alpha value.
       attr_reader :alpha
 
       def self.from_hash(hash)
@@ -84,6 +82,7 @@ module DNN
 
       # @param [Float] alpha The slope when the output value is negative.
       def initialize(alpha = 0.3)
+        super()
         @alpha = alpha
       end
 
@@ -101,13 +100,12 @@ module DNN
       end
 
       def to_hash
-        {class: self.class.name, alpha: alpha}
+        super(alpha: @alpha)
       end
     end
 
 
     class ELU < Layers::Layer
-      # @return [Float] Return the alpha value.
       attr_reader :alpha
 
       def self.from_hash(hash)
@@ -116,6 +114,7 @@ module DNN
 
       # @param [Float] alpha The slope when the output value is negative.
       def initialize(alpha = 1.0)
+        super()
         @alpha = alpha
       end
 
@@ -126,7 +125,7 @@ module DNN
         x1 *= x
         x2 = Xumo::SFloat.zeros(x.shape)
         x2[x < 0] = 1
-        x2 *= @alpha * NMath.exp(x) - @alpha
+        x2 *= @alpha * Xumo::NMath.exp(x) - @alpha
         x1 + x2
       end
 
@@ -135,12 +134,12 @@ module DNN
         dx[@x < 0] = 0
         dx2 = Xumo::SFloat.zeros(@x.shape)
         dx2[@x < 0] = 1
-        dx2 *= @alpha * NMath.exp(@x)
+        dx2 *= @alpha * Xumo::NMath.exp(@x)
         dy * (dx + dx2)
       end
 
       def to_hash
-        {class: self.class.name, alpha: @alpha}
+        super(alpha: @alpha)
       end
     end
 

data/lib/dnn/core/cnn_layers.rb

@@ -1,7 +1,8 @@
 module DNN
   module Layers
+
     # This module is used for convolution.
-    module Conv2D_Utils
+    module Conv2DUtils
       private
 
       # img[bsize, out_h, out_w, ch] to col[bsize * out_h * out_w, fil_h * fil_w * ch]
@@ -59,53 +60,53 @@ module DNN
         [out_h, out_w]
       end
 
-      def calc_deconv2d_out_size(prev_h, prev_w, fil_h, fil_w, pad_h, pad_w, strides)
+      def calc_conv2d_transpose_out_size(prev_h, prev_w, fil_h, fil_w, pad_h, pad_w, strides)
         out_h = (prev_h - 1) * strides[0] + fil_h - pad_h
         out_w = (prev_w - 1) * strides[1] + fil_w - pad_w
         [out_h, out_w]
       end
 
-      def calc_padding_size(prev_h, prev_w, out_h, out_w, strides)
-        pad_h = (prev_h.to_f / strides[0]).ceil - out_h
-        pad_w = (prev_w.to_f / strides[1]).ceil - out_w
+      def calc_conv2d_padding_size(prev_h, prev_w, fil_h, fil_w, strides)
+        out_h = prev_h / strides[0]
+        out_w = prev_w / strides[1]
+        pad_h = out_h * strides[0] - prev_h + fil_h - strides[0]
+        pad_w = out_w * strides[1] - prev_w + fil_w - strides[1]
         [pad_h, pad_w]
       end
 
-      def calc_padding_size(prev_h, prev_w, out_h, out_w, strides)
-        pad_h = ((prev_h.to_f / strides[0]).ceil - out_h) * strides[0]
-        pad_w = ((prev_w.to_f / strides[1]).ceil - out_w) * strides[1]
+      def calc_conv2d_transpose_padding_size(prev_h, prev_w, fil_h, fil_w, strides)
+        out_h = prev_h * strides[0]
+        out_w = prev_w * strides[1]
+        pad_h = (prev_h - 1) * strides[0] + fil_h - out_h
+        pad_w = (prev_w - 1) * strides[1] + fil_w - out_w
         [pad_h, pad_w]
       end
     end
-    
-    
+
+
     class Conv2D < Connection
-      include Conv2D_Utils
+      include Conv2DUtils
 
-      # @return [Integer] number of filters.
       attr_reader :num_filters
-      # @return [Array] Return filter size. filter size is of the form [height, width].
       attr_reader :filter_size
-      # @return [Array] Return stride length. stride length is of the form [height, width].
       attr_reader :strides
-      # @return [Array | Bool] Return padding size or whether to padding.
       attr_reader :padding
 
       def self.from_hash(hash)
-        Conv2D.new(hash[:num_filters], hash[:filter_size],
-                   weight_initializer: Utils.from_hash(hash[:weight_initializer]),
-                   bias_initializer: Utils.from_hash(hash[:bias_initializer]),
-                   weight_regularizer: Utils.from_hash(hash[:weight_regularizer]),
-                   bias_regularizer: Utils.from_hash(hash[:bias_regularizer]),
-                   use_bias: hash[:use_bias],
-                   strides: hash[:strides],
-                   padding: hash[:padding])
-      end
-      
+        self.new(hash[:num_filters], hash[:filter_size],
+                 weight_initializer: Utils.hash_to_obj(hash[:weight_initializer]),
+                 bias_initializer: Utils.hash_to_obj(hash[:bias_initializer]),
+                 weight_regularizer: Utils.hash_to_obj(hash[:weight_regularizer]),
+                 bias_regularizer: Utils.hash_to_obj(hash[:bias_regularizer]),
+                 use_bias: hash[:use_bias],
+                 strides: hash[:strides],
+                 padding: hash[:padding])
+      end
+
       # @param [Integer] num_filters Number of filters.
       # @param [Array | Integer] filter_size Filter size. Filter size is of the form [height, width].
       # @param [Array | Integer] strides Stride length. Stride length is of the form [height, width].
-      # @param [Array | Bool] padding Padding size or whether to padding. Padding size is of the form [height, width].
+      # @param [Array | Boolean] padding Padding size or whether to padding. Padding size is of the form [height, width].
       def initialize(num_filters, filter_size,
                      weight_initializer: Initializers::RandomNormal.new,
                      bias_initializer: Initializers::Zeros.new,
@@ -127,17 +128,16 @@ module DNN
           raise DNN_ShapeError.new("Input shape is #{input_shape}. But input shape must be 3 dimensional.")
         end
         super
-        prev_h, prev_w, num_prev_filter = *input_shape
-        @weight.data = Xumo::SFloat.new(@filter_size.reduce(:*) * num_prev_filter, @num_filters)
+        prev_h, prev_w, num_prev_filters = *input_shape
+        @weight.data = Xumo::SFloat.new(@filter_size.reduce(:*) * num_prev_filters, @num_filters)
         @bias.data = Xumo::SFloat.new(@num_filters) if @bias
         init_weight_and_bias
-        if @padding == true
-          out_h, out_w = calc_conv2d_out_size(prev_h, prev_w, *@filter_size, 0, 0, @strides)
-          @pad_size = calc_padding_size(prev_h, prev_w, out_h, out_w, @strides)
+        @pad_size = if @padding == true
+          calc_conv2d_padding_size(prev_h, prev_w, *@filter_size, @strides)
         elsif @padding.is_a?(Array)
-          @pad_size = @padding
+          @padding
         else
-          @pad_size = [0, 0]
+          [0, 0]
         end
         @out_size = calc_conv2d_out_size(prev_h, prev_w, *@filter_size, *@pad_size, @strides)
       end
@@ -168,48 +168,44 @@ module DNN
 
       # @return [Numo::SFloat] Convert weight to filter and return.
       def filters
-        num_prev_filter = @input_shape[2]
-        @weight.data.reshape(*@filter_size, num_prev_filter, @num_filters)
+        num_prev_filters = @input_shape[2]
+        @weight.data.reshape(*@filter_size, num_prev_filters, @num_filters)
       end
 
       # @param [Numo::SFloat] filters Convert weight to filters and set.
       def filters=(filters)
-        num_prev_filter = @input_shape[2]
-        @weight.data = filters.reshape(@filter_size.reduce(:*) * num_prev_filter, @num_filters)
+        num_prev_filters = @input_shape[2]
+        @weight.data = filters.reshape(@filter_size.reduce(:*) * num_prev_filters, @num_filters)
       end
 
       def to_hash
-        super({num_filters: @num_filters,
-               filter_size: @filter_size,
-               strides: @strides,
-               padding: @padding})
+        super(num_filters: @num_filters,
+              filter_size: @filter_size,
+              strides: @strides,
+              padding: @padding)
       end
     end
 
 
-    class Conv2D_Transpose < Connection
-      include Conv2D_Utils
+    class Conv2DTranspose < Connection
+      include Conv2DUtils
 
-      # @return [Integer] number of filters.
       attr_reader :num_filters
-      # @return [Array] Return filter size. filter size is of the form [height, width].
       attr_reader :filter_size
-      # @return [Array] Return stride length. stride length is of the form [height, width].
       attr_reader :strides
-      # @return [Array] Return padding size.
       attr_reader :padding
 
       def self.from_hash(hash)
-        Conv2D_Transpose.new(hash[:num_filters], hash[:filter_size],
-                   weight_initializer: Utils.from_hash(hash[:weight_initializer]),
-                   bias_initializer: Utils.from_hash(hash[:bias_initializer]),
-                   weight_regularizer: Utils.from_hash(hash[:weight_regularizer]),
-                   bias_regularizer: Utils.from_hash(hash[:bias_regularizer]),
-                   use_bias: hash[:use_bias],
-                   strides: hash[:strides],
-                   padding: hash[:padding])
-      end
-      
+        self.new(hash[:num_filters], hash[:filter_size],
+                 weight_initializer: Utils.hash_to_obj(hash[:weight_initializer]),
+                 bias_initializer: Utils.hash_to_obj(hash[:bias_initializer]),
+                 weight_regularizer: Utils.hash_to_obj(hash[:weight_regularizer]),
+                 bias_regularizer: Utils.hash_to_obj(hash[:bias_regularizer]),
+                 use_bias: hash[:use_bias],
+                 strides: hash[:strides],
+                 padding: hash[:padding])
+      end
+
       # @param [Integer] num_filters Number of filters.
       # @param [Array | Integer] filter_size Filter size. Filter size is of the form [height, width].
       # @param [Array | Integer] strides Stride length. Stride length is of the form [height, width].
@@ -235,19 +231,18 @@ module DNN
           raise DNN_ShapeError.new("Input shape is #{input_shape}. But input shape must be 3 dimensional.")
         end
         super
-        prev_h, prev_w, num_prev_filter = *input_shape
-        @weight.data = Xumo::SFloat.new(@filter_size.reduce(:*) * @num_filters, num_prev_filter)
+        prev_h, prev_w, num_prev_filters = *input_shape
+        @weight.data = Xumo::SFloat.new(@filter_size.reduce(:*) * @num_filters, num_prev_filters)
         @bias.data = Xumo::SFloat.new(@num_filters) if @bias
         init_weight_and_bias
-        if @padding == true
-          out_h, out_w = calc_deconv2d_out_size(prev_h, prev_w, *@filter_size, 0, 0, @strides)
-          @pad_size = calc_padding_size(out_h, out_w, prev_h, prev_w, @strides)
+        @pad_size = if @padding == true
+          calc_conv2d_transpose_padding_size(prev_h, prev_w, *@filter_size, @strides)
         elsif @padding.is_a?(Array)
-          @pad_size = @padding
+          @padding
         else
-          @pad_size = [0, 0]
+          [0, 0]
         end
-        @out_size = calc_deconv2d_out_size(prev_h, prev_w, *@filter_size, *@pad_size, @strides)
+        @out_size = calc_conv2d_transpose_out_size(prev_h, prev_w, *@filter_size, *@pad_size, @strides)
       end
 
       def forward(x)
@@ -278,44 +273,41 @@ module DNN
 
       # @return [Numo::SFloat] Convert weight to filter and return.
       def filters
-        num_prev_filter = @input_shape[2]
-        @weight.data.reshape(*@filter_size, @num_filters, num_prev_filter)
+        num_prev_filters = @input_shape[2]
+        @weight.data.reshape(*@filter_size, @num_filters, num_prev_filters)
       end
 
       # @param [Numo::SFloat] filters Convert weight to filters and set.
       def filters=(filters)
-        num_prev_filter = @input_shape[2]
-        @weight.data = filters.reshape(@filter_size.reduce(:*) * @num_filters, num_prev_filter)
+        num_prev_filters = @input_shape[2]
+        @weight.data = filters.reshape(@filter_size.reduce(:*) * @num_filters, num_prev_filters)
       end
 
       def to_hash
-        super({num_filters: @num_filters,
-               filter_size: @filter_size,
-               strides: @strides,
-               padding: @padding})
+        super(num_filters: @num_filters,
+              filter_size: @filter_size,
+              strides: @strides,
+              padding: @padding)
       end
     end
 
-    
+
     # Super class of all pooling2D class.
     class Pool2D < Layer
-      include Conv2D_Utils
+      include Conv2DUtils
 
-      # @return [Array] Return pooling size. Pooling size is of the form [height, width].
       attr_reader :pool_size
-      # @return [Array] Return stride length. Stride length is of the form [height, width].
       attr_reader :strides
-      # @return [Array | Bool] Return padding size or whether to padding.
       attr_reader :padding
 
-      def self.from_hash(pool2d_class, hash)
-        pool2d_class.new(hash[:pool_size], strides: hash[:strides], padding: hash[:padding])
+      def self.from_hash(hash)
+        self.new(hash[:pool_size], strides: hash[:strides], padding: hash[:padding])
       end
 
       # @param [Array | Integer] pool_size Pooling size. Pooling size is of the form [height, width].
-      # @param [Array | Integer | NilClass] strides stride length. Stride length is of the form [height, width].
-      #   If you set nil, treat pool_size as strides.
-      # @param [Array | Bool] padding Padding size or whether to padding. Padding size is of the form [height, width].
+      # @param [Array | Integer | NilClass] strides Stride length. Stride length is of the form [height, width].
+      #                                             If you set nil, treat pool_size as strides.
+      # @param [Array | Boolean] padding Padding size or whether to padding. Padding size is of the form [height, width].
       def initialize(pool_size, strides: nil, padding: false)
         super()
         @pool_size = pool_size.is_a?(Integer) ? [pool_size, pool_size] : pool_size
@@ -334,13 +326,12 @@ module DNN
         super
         prev_h, prev_w = input_shape[0..1]
         @num_channel = input_shape[2]
-        if @padding == true
-          out_h, out_w = calc_conv2d_out_size(prev_h, prev_w, *@pool_size, 0, 0, @strides)
-          @pad_size = calc_padding_size(prev_h, prev_w, out_h, out_w, @strides)
+        @pad_size = if @padding == true
+          calc_conv2d_padding_size(prev_h, prev_w, *@pool_size, @strides)
         elsif @padding.is_a?(Array)
-          @pad_size = @padding
+          @padding
         else
-          @pad_size = [0, 0]
+          [0, 0]
         end
         @out_size = calc_conv2d_out_size(prev_h, prev_w, *@pool_size, *@pad_size, @strides)
       end
@@ -350,18 +341,14 @@ module DNN
       end
 
       def to_hash
-        super({pool_size: @pool_size,
-               strides: @strides,
-               padding: @padding})
+        super(pool_size: @pool_size,
+              strides: @strides,
+              padding: @padding)
       end
     end
-    
-    
-    class MaxPool2D < Pool2D
-      def self.from_hash(hash)
-        Pool2D.from_hash(self, hash)
-      end
 
+
+    class MaxPool2D < Pool2D
       def forward(x)
         x = zero_padding(x, @pad_size) if @padding
         @x_shape = x.shape
@@ -383,10 +370,6 @@ module DNN
 
 
     class AvgPool2D < Pool2D
-      def self.from_hash(hash)
-        Pool2D.from_hash(self, hash)
-      end
-
       def forward(x)
         x = zero_padding(x, @pad_size) if @padding
         @x_shape = x.shape
@@ -411,21 +394,20 @@ module DNN
 
 
     class UnPool2D < Layer
-      include Conv2D_Utils
-      
-      # @return [Array] Return unpooling size. unpooling size is of the form [height, width].
+      include Conv2DUtils
+
       attr_reader :unpool_size
 
-      # @param [Array or Integer] unpool_size Unpooling size. unpooling size is of the form [height, width].
+      def self.from_hash(hash)
+        self.new(hash[:unpool_size])
+      end
+
+      # @param [Array | Integer] unpool_size Unpooling size. unpooling size is of the form [height, width].
       def initialize(unpool_size)
         super()
         @unpool_size = unpool_size.is_a?(Integer) ? [unpool_size, unpool_size] : unpool_size
       end
 
-      def self.from_hash(hash)
-        UnPool2D.new(hash[:unpool_size])
-      end
-
       def build(input_shape)
         unless input_shape.length == 3
           raise DNN_ShapeError.new("Input shape is #{input_shape}. But input shape must be 3 dimensional.")
@@ -453,7 +435,7 @@ module DNN
 
       def backward(dy)
         in_size = input_shape[0..1]
-        col = im2col(dy, *input_shape[0..1], *@unpool_size, @unpool_size)
+        col = im2col(dy, *in_size, *@unpool_size, @unpool_size)
         col = col.reshape(dy.shape[0] * in_size.reduce(:*), @unpool_size.reduce(:*), dy.shape[3]).transpose(0, 2, 1)
                  .reshape(dy.shape[0] * in_size.reduce(:*) * dy.shape[3], @unpool_size.reduce(:*))
         col.sum(1).reshape(dy.shape[0], *in_size, dy.shape[3])
@@ -464,8 +446,9 @@ module DNN
       end
 
       def to_hash
-        super({unpool_size: @unpool_size})
+        super(unpool_size: @unpool_size)
       end
     end
+
   end
 end