ruby-dnn 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0db9ac3047ba8c15d903ace901f5e4e332835d11dffca2f441664ae843049d1d
-  data.tar.gz: f1b4bf61da8a48b8ad483eb806ab443bb40f1b0d88573c2d901ae45299abf86d
+  metadata.gz: 62482330aab914fc53313fa7a1170a53ea3644e72dfe1cecb2fffca1160f6f7e
+  data.tar.gz: e21d0e28ba2c603179ece6fe9cb2c4722ea8bbaa85c72cc357f8b5fa691e33d0
 SHA512:
-  metadata.gz: 880fe0688bb5b15c016fdddb15b18f5e0b3ba2a45ae36292182adf8def20d93ca3ae176747dbf3d1369ea28cdaaf23e7cd9e96d0a0c6c4bb92db27131d8f4d93
-  data.tar.gz: 4d00dc6831f0c82e0dc1b4128d98dc391456410cbf26e0d0192b19092333664774eccabd2db0a609b739c1c40664e148dcd69152cdc45394690e21d785e1acc0
+  metadata.gz: 5f7a34efbba1465aa4e245b83928bbbe764d67708e9e6c3faef7030b13873dc27f775adbf8b32b0f3015280f1b3bbb600a1e4c4bff9c1a5be40387217efc2e26
+  data.tar.gz: 9bba32d0b4142df90ab07b75191bb7590fa000f38470f9d9149f4cd95c346f5ba90fbf4549d714dee5374d1024184cf45eb61bcd1ba3e10e1ab0aa5eda398011

data/Rakefile

@@ -1,5 +1,7 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "yard"
+require "yard/rake/yardoc_task"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -18,10 +20,12 @@ end
 
 task :default => [:test, :build_rb_stb_image]
 
-task :doc do
-  src_list = Dir["lib/dnn.rb"]
-  src_list += Dir["lib/dnn/core/*.rb"]
-  src_list += Dir["lib/dnn/core/layers/*.rb"]
-  src_list += Dir["lib/dnn/*.rb"]
-  sh "yardoc #{src_list.join(' ')}"
+YARD::Rake::YardocTask.new do |t|
+  t.files = [
+    "lib/dnn.rb",
+    "lib/dnn/core/*.rb",
+    "lib/dnn/core/layers/*.rb",
+    "lib/dnn/*.rb",
+    "lib/dnn/datasets/*.rb",
+  ]
 end

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

@@ -7,6 +7,7 @@ module DNN
         prev = (input.is_a?(Tensor) ? input.link : input)
         y = forward_node(x)
         link = Link.new(prev, self)
+        prev.next = link if prev.is_a?(Link)
         Tensor.new(y, link)
       end
 
@@ -77,6 +78,10 @@ module DNN
         @input_shape
       end
 
+      def <<(tensor)
+        self.(tensor)
+      end
+
       # Layer to a hash.
       def to_hash(merge_hash = nil)
         hash = { class: self.class.name }
@@ -154,20 +159,6 @@ module DNN
         method(:call).to_proc
       end
 
-      def >>(layer)
-        if RUBY_VERSION < "2.6.0"
-          raise DNNError, "Function composition is not supported before ruby version 2.6.0."
-        end
-        to_proc >> layer
-      end
-
-      def <<(layer)
-        if RUBY_VERSION < "2.6.0"
-          raise DNNError, "Function composition is not supported before ruby version 2.6.0."
-        end
-        to_proc << layer
-      end
-
       def to_hash
         super(input_shape: @input_shape)
       end

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

@@ -8,6 +8,7 @@ module DNN
       attr_reader :weight
       attr_reader :weight_initializer
       attr_reader :weight_regularizer
+      attr_reader :mask_zero
 
       # @param [Integer | Array] input_dim_or_shape Set input data dimension or shape.
       # @param [Integer] input_length Set the time series length of input data.
@@ -15,13 +16,15 @@ module DNN
       # @param [DNN::Regularizers::Regularizer | NilClass] weight_regularizer Weight regularizer.
       def initialize(input_dim_or_shape, input_length,
                      weight_initializer: Initializers::RandomUniform.new,
-                     weight_regularizer: nil)
+                     weight_regularizer: nil,
+                     mask_zero: false)
         super()
         @input_shape = input_dim_or_shape.is_a?(Array) ? input_dim_or_shape : [input_dim_or_shape]
         @input_length = input_length
         @weight_initializer = weight_initializer
         @weight_regularizer = weight_regularizer
         @weight = Param.new(nil, Xumo::SFloat[0])
+        @mask_zero = mask_zero
       end
 
       def build(input_shape)
@@ -35,7 +38,14 @@ module DNN
         @x = x
         y = Xumo::SFloat.zeros(*x.shape)
         x.shape[0].times do |i|
-          y[i, false] = @weight.data[x[i, false]]
+          if @mask_zero
+            x.shape[1].times do |j|
+              index = x[i, j]
+              y[i, j] = index == 0 ? 0 : @weight.data[index]
+            end
+          else
+            y[i, false] = @weight.data[x[i, false]]
+          end
         end
         y
       end
@@ -44,7 +54,12 @@ module DNN
         @weight.grad += Xumo::SFloat.zeros(*@weight.data.shape)
         @x.shape[0].times do |i|
           @x.shape[1].times do |j|
-            @weight.grad[@x[i, j]] += dy[i, j]
+            index = @x[i, j]
+            if @mask_zero
+              @weight.grad[index] += dy[i, j] unless index == 0
+            else
+              @weight.grad[index] += dy[i, j]
+            end
           end
         end
         nil
@@ -56,13 +71,15 @@ module DNN
 
       def to_hash
         super(input_shape: @input_shape, input_length: @input_length,
-              weight_initializer: @weight_initializer.to_hash, weight_regularizer: @weight_regularizer&.to_hash)
+              weight_initializer: @weight_initializer.to_hash, weight_regularizer: @weight_regularizer&.to_hash,
+              mask_zero: @mask_zero)
       end
 
       def load_hash(hash)
         initialize(hash[:input_shape], hash[:input_length],
                    weight_initializer: Initializers::Initializer.from_hash(hash[:weight_initializer]),
-                   weight_regularizer: Regularizers::Regularizer.from_hash(hash[:weight_regularizer]))
+                   weight_regularizer: Regularizers::Regularizer.from_hash(hash[:weight_regularizer]),
+                   mask_zero: hash[:mask_zero])
       end
 
       def get_params

data/lib/dnn/core/link.rb

@@ -1,14 +1,21 @@
 module DNN
   class Link
     attr_accessor :prev
+    attr_accessor :next
     attr_accessor :layer_node
 
     def initialize(prev = nil, layer_node = nil)
       @prev = prev
       @layer_node = layer_node
+      @next = nil
     end
 
-    def backward(dy = Numo::SFloat[1])
+    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
@@ -17,15 +24,26 @@ module DNN
   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
       @layer_node = layer_node
+      @next = nil
+      @hold = []
+    end
+
+    def forward(x)
+      @hold << x
+      return if @hold.length < 2
+      x = @layer_node.(*@hold)
+      @hold = []
+      @next ? @next.forward(x) : x
     end
 
-    def backward(dy = Numo::SFloat[1])
+    def backward(dy = Xumo::SFloat[1])
       dys = @layer_node.backward_node(dy)
       if dys.is_a?(Array)
         dy1, dy2 = *dys

data/lib/dnn/core/models.rb

@@ -72,12 +72,43 @@ module DNN
         end
         @layers_cache = layers_array
       end
+
+      def to_hash
+        layers_hash = { class: self.class.name }
+        instance_variables.sort.each do |ivar|
+          obj = instance_variable_get(ivar)
+          if obj.is_a?(Layers::Layer) || obj.is_a?(Chain)
+            layers_hash[ivar] = obj.to_hash
+          elsif obj.is_a?(LayersList)
+            layers_hash[ivar] = obj.to_hash_list
+          end
+        end
+        layers_hash
+      end
+
+      def load_hash(layers_hash)
+        instance_variables.sort.each do |ivar|
+          hash_or_array = layers_hash[ivar]
+          if hash_or_array.is_a?(Array)
+            instance_variable_set(ivar, LayersList.from_hash_list(hash_or_array))
+          elsif hash_or_array.is_a?(Hash)
+            obj_class = DNN.const_get(hash_or_array[:class])
+            obj = obj_class.allocate
+            if obj.is_a?(Chain)
+              obj = obj_class.new
+              obj.load_hash(hash_or_array)
+              instance_variable_set(ivar, obj)
+            else
+              instance_variable_set(ivar, Layers::Layer.from_hash(hash_or_array))
+            end
+          end
+        end
+      end
     end
 
     # This class deals with the model of the network.
     class Model < Chain
       attr_accessor :optimizer
-      attr_accessor :loss_func
       attr_reader :last_log
 
       # Load marshal model.
@@ -100,9 +131,9 @@ module DNN
       end
 
       def call(input_tensors)
-        output_tensor = forward(input_tensors)
+        output_tensors = forward(input_tensors)
         @built = true unless @built
-        output_tensor
+        output_tensors
       end
 
       # Set optimizer and loss_func to model.
@@ -112,11 +143,29 @@ module DNN
         unless optimizer.is_a?(Optimizers::Optimizer)
           raise TypeError, "optimizer:#{optimizer.class} is not an instance of DNN::Optimizers::Optimizer class."
         end
-        unless loss_func.is_a?(Losses::Loss)
-          raise TypeError, "loss_func:#{loss_func.class} is not an instance of DNN::Losses::Loss class."
+        unless loss_func.is_a?(Losses::Loss) || loss_func.is_a?(Array)
+          raise TypeError, "loss_func:#{loss_func.class} is not an instance of DNN::Losses::Loss or Array class."
         end
         @optimizer = optimizer
-        @loss_func = loss_func
+        self.loss_func = loss_func
+      end
+
+      def loss_func
+        @loss_func
+      end
+
+      def loss_func=(lfs)
+        if lfs.is_a?(Array)
+          @loss_func = []
+          lfs.each.with_index do |lf, i|
+            unless lf.is_a?(Losses::Loss)
+              raise TypeError, "loss_func[#{i}]:#{lf.class} is not an instance of DNN::Losses::Loss class."
+            end
+            @loss_func << lf
+          end
+        else
+          @loss_func = lfs
+        end
       end
 
       # Start training.
@@ -232,13 +281,28 @@ module DNN
         check_xy_type(x, y)
         call_callbacks(:before_train_on_batch)
         DNN.learning_phase = true
-        out = call(Tensor.convert(x))
-        loss = @loss_func.loss(out, Tensor.convert(y), layers)
-        loss.link.backward(Xumo::SFloat.ones(y[0...1, false].shape[0], 1))
+        output_tensors = call(Tensor.convert(x))
+        if output_tensors.is_a?(Array)
+          loss_data = []
+          output_tensors.each.with_index do |out, i|
+            loss = if i == 0
+              @loss_func[i].loss(out, Tensor.convert(y[i]), layers)
+            else
+              @loss_func[i].loss(out, Tensor.convert(y[i]))
+            end
+            loss_data << loss.data.to_f
+            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)
+          loss_data = loss.data.to_f
+          loss.link.backward(Xumo::SFloat.ones(y[0...1, false].shape[0], 1))
+        end
         @optimizer.update(get_all_trainable_params)
-        @last_log[:train_loss] = loss.data
+        @last_log[:train_loss] = loss_data
         call_callbacks(:after_train_on_batch)
-        loss.data
+        loss_data
       end
 
       # Evaluate model and get accuracy and loss of test data.
@@ -258,33 +322,66 @@ module DNN
       def evaluate_by_iterator(test_iterator, batch_size: 100)
         num_test_datas = test_iterator.num_datas
         batch_size = batch_size >= num_test_datas ? num_test_datas : batch_size
-        total_correct = 0
-        sum_loss = 0
+        if @loss_func.is_a?(Array)
+          total_correct = Array.new(@loss_func.length, 0)
+          sum_loss = Array.new(@loss_func.length, 0)
+        else
+          total_correct = 0
+          sum_loss = 0
+        end
         max_steps = (num_test_datas.to_f / batch_size).ceil
         test_iterator.foreach(batch_size) do |x_batch, y_batch|
           correct, loss_value = test_on_batch(x_batch, y_batch)
-          total_correct += correct
-          sum_loss += loss_value
+          if @loss_func.is_a?(Array)
+            @loss_func.each_index do |i|
+              total_correct[i] += correct[i]
+              sum_loss[i] += loss_value[i]
+            end
+          else
+            total_correct += correct
+            sum_loss += loss_value
+          end
+        end
+        if @loss_func.is_a?(Array)
+          mean_loss = Array.new(@loss_func.length, 0)
+          acc = Array.new(@loss_func.length, 0)
+          @loss_func.each_index do |i|
+            mean_loss[i] += sum_loss[i] / max_steps
+            acc[i] += total_correct[i].to_f / num_test_datas
+          end
+        else
+          mean_loss = sum_loss / max_steps
+          acc = total_correct.to_f / num_test_datas
         end
-        mean_loss = sum_loss / max_steps
-        acc = total_correct.to_f / num_test_datas
         @last_log[:test_loss] = mean_loss
         @last_log[:test_accuracy] = acc
         [acc, mean_loss]
       end
 
       # Evaluate once.
-      # @param [Numo::SFloat] x Input test data.
-      # @param [Numo::SFloat] y Output test data.
+      # @param [Numo::SFloat | Array] x Input test data.
+      # @param [Numo::SFloat | Array] y Output test data.
       # @return [Array] Returns the test data accuracy and mean loss in the form [accuracy, mean_loss].
       def test_on_batch(x, y)
         call_callbacks(:before_test_on_batch)
         DNN.learning_phase = false
-        out = call(Tensor.convert(x))
-        correct = accuracy(out.data, y)
-        loss = @loss_func.(out, Tensor.convert(y))
+        output_tensors = call(Tensor.convert(x))
+        if output_tensors.is_a?(Array)
+          correct = []
+          loss_data = []
+          output_tensors.each.with_index do |out, i|
+            correct << accuracy(out.data, y[i])
+            loss = @loss_func[i].(out, Tensor.convert(y[i]))
+            loss_data << loss.data.to_f
+          end
+        else
+          out = output_tensors
+          correct = accuracy(out.data, y)
+          loss = @loss_func.(out, Tensor.convert(y))
+          loss_data = loss.data.to_f
+        end
         call_callbacks(:after_test_on_batch)
-        [correct, loss.data]
+        [correct, loss_data]
       end
 
       # Implement the process to accuracy this model.
@@ -313,12 +410,23 @@ module DNN
       def predict(x, use_loss_activation: true)
         check_xy_type(x)
         DNN.learning_phase = false
-        out = call(Tensor.convert(x))
-        y = out.data
-        if use_loss_activation && @loss_func.class.respond_to?(:activation)
-          y = @loss_func.class.activation(y)
+        output_tensors = call(Tensor.convert(x))
+        if output_tensors.is_a?(Array)
+          lfs = @loss_func
+          ary_output_tensors = output_tensors
+        else
+          lfs = [@loss_func]
+          ary_output_tensors = [output_tensors]
+        end
+        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)
+          end
+          ys << y
         end
-        y
+        output_tensors.is_a?(Array) ? ys : ys.first
       end
 
       # Predict one data.
@@ -433,16 +541,38 @@ module DNN
       end
 
       def metrics_to_str(mertics)
-        mertics.map { |key, num| "#{key}: #{sprintf('%.4f', num)}" }.join(", ")
+        mertics.map { |key, values|
+          str_values = if values.is_a?(Array)
+                         values_fmt = values.map { |v| sprintf('%.4f', v) }
+                         "[#{values_fmt.join(", ")}]"
+                       else
+                         sprintf('%.4f', values)
+                       end
+          "#{key}: #{str_values}"
+        }.join(", ")
       end
 
       def check_xy_type(x, y = nil)
         if !x.is_a?(Xumo::SFloat) && !x.is_a?(Array)
           raise TypeError, "x:#{x.class.name} is not an instance of #{Xumo::SFloat.name} class or Array class."
         end
+        if x.is_a?(Array)
+          x.each.with_index do |v, i|
+            unless v.is_a?(Xumo::SFloat)
+              raise TypeError, "x[#{i}]:#{v.class.name} is not an instance of #{Xumo::SFloat.name} class."
+            end
+          end
+        end
         if y && !y.is_a?(Xumo::SFloat) && !y.is_a?(Array)
           raise TypeError, "y:#{y.class.name} is not an instance of #{Xumo::SFloat.name} class or Array class."
         end
+        if y.is_a?(Array)
+          y.each.with_index do |v, i|
+            unless v.is_a?(Xumo::SFloat)
+              raise TypeError, "x[#{i}]:#{v.class.name} is not an instance of #{Xumo::SFloat.name} class."
+            end
+          end
+        end
       end
     end
 
@@ -459,14 +589,14 @@ module DNN
       end
 
       # Add layer to the model.
-      # @param [DNN::Layers::Layer] layer Layer to add to the model.
+      # @param [DNN::Layers::Layer | DNN::Models::Chain] layer Layer or Chain to add to the model.
       # @return [DNN::Models::Model] Return self.
       def add(layer)
         if layer.is_a?(Layers::MergeLayer)
           raise TypeError, "layer: #{layer.class.name} should not be a DNN::Layers::MergeLayer class."
         end
-        unless layer.is_a?(Layers::Layer) || layer.is_a?(Model)
-          raise TypeError, "layer: #{layer.class.name} is not an instance of the DNN::Layers::Layer class or DNN::Models::Model class."
+        unless layer.is_a?(Layers::Layer) || layer.is_a?(Chain)
+          raise TypeError, "layer: #{layer.class.name} is not an instance of the DNN::Layers::Layer class or DNN::Models::Chain class."
         end
         @stack << layer
         self
@@ -475,20 +605,20 @@ module DNN
       alias << add
 
       # Insert layer to the model by index position.
-      # @param [DNN::Layers::Layer] layer Layer to add to the model.
+      # @param [DNN::Layers::Layer | DNN::Models::Chain] layer Layer or Chain to add to the model.
       # @return [DNN::Models::Model] Return self.
       def insert(index, layer)
         if layer.is_a?(Layers::MergeLayer)
           raise TypeError, "layer: #{layer.class.name} should not be a DNN::Layers::MergeLayer class."
         end
-        unless layer.is_a?(Layers::Layer) || layer.is_a?(Model)
-          raise TypeError, "layer: #{layer.class.name} is not an instance of the DNN::Layers::Layer class or DNN::Models::Model class."
+        unless layer.is_a?(Layers::Layer) || layer.is_a?(Chain)
+          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)
       end
 
       # Remove layer to the model.
-      # @param [DNN::Layers::Layer] layer Layer to remove to the model.
+      # @param [DNN::Layers::Layer | DNN::Models::Chain] layer Layer to remove to the model.
       # @return [Boolean] Return true if success for remove layer.
       def remove(layer)
         @stack.delete(layer) ? true : false
@@ -502,5 +632,40 @@ module DNN
       end
     end
 
+    class FixedModel < Model
+      attr_reader :layers
+
+      def initialize(output_tensor, layers)
+        super()
+        @input_link = get_input_link(output_tensor.link)
+        @layers = layers
+      end
+
+      def forward(input_tensors)
+        if input_tensors.is_a?(Array)
+          input_tensors.each do |tensor|
+            @input_link.forward(tensor)
+          end
+        else
+          @input_link.forward(input_tensors)
+        end
+      end
+
+      private
+
+      def get_input_link(last_link)
+        get_input_link = -> link do
+          if link.is_a?(Link)
+            return link unless link.prev
+            get_input_link.(link.prev)
+          else
+            return link unless link.prev1
+            get_input_link.(link.prev1)
+          end
+        end
+        get_input_link.(last_link)
+      end
+    end
+
   end
 end

data/lib/dnn/core/savers.rb

@@ -97,7 +97,7 @@ module DNN
         if @include_model
           @model.clean_layers
           data = {
-            version: VERSION, class: @model.class.name, input_shape: @model.layers.first.input_shape,
+            version: VERSION, class: @model.class.name,
             params: params_data, model: @model
           }
         else

data/lib/dnn/core/tensor.rb

@@ -16,6 +16,10 @@ module DNN
       @link = link
     end
 
+    def >>(layer)
+      layer.(self)
+    end
+
     def shape
       @data.shape
     end

data/lib/dnn/keras-model-convertor.rb

@@ -0,0 +1,170 @@
+# This library is not yet complete.
+
+# This library converts keras models to ruby-dnn models.
+# Use of the library requires the installation of PyCall.
+
+require "pycall/import"
+require "numpy"
+require_relative "numo2numpy"
+
+include PyCall::Import
+
+pyimport :numpy, as: :np
+pyimport :keras
+pyfrom :"keras.models", import: :Sequential
+pyfrom :"keras.layers", import: [:Dense, :Dropout, :Conv2D, :Activation, :MaxPooling2D, :Flatten]
+pyfrom :"keras.layers.normalization", import: :BatchNormalization
+
+class DNNKerasModelConvertError < DNN::DNNError; end
+
+class KerasModelConvertor
+  pyfrom :"keras.models", import: :load_model
+
+  def self.k_load_model(k_model_name, k_weights_name)
+    model = load_model(k_model_name)
+    model.load_weights(k_weights_name) if k_weights_name
+    model
+  end
+
+  def initialize(k_model_name, k_weights_name = nil)
+    @k_model = KerasModelConvertor.k_load_model(k_model_name, k_weights_name)
+  end
+
+  def convert
+    unless @k_model.__class__.__name__ == "Sequential"
+      raise DNNKerasModelConvertError.new("#{@k_model.__class__.__name__} models do not support convert.")
+    end
+    dnn_model = DNN::Models::Sequential.new
+    @k_model.layers.each do |k_layer|
+      dnn_layer = layer_convert(k_layer)
+      dnn_model << dnn_layer if dnn_layer
+    end
+    input_shape = @k_model.layers[0].input_shape.to_a[1..-1]
+    input_layer = DNN::Layers::InputLayer.new(input_shape)
+    input_layer.build(input_shape)
+    dnn_model.insert(0, input_layer)
+    dnn_model
+  end
+
+  private
+
+  def layer_convert(k_layer)
+    k_layer_name = k_layer.__class__.__name__
+    method_name = "convert_" + k_layer_name
+    if respond_to?(method_name, true)
+      send(method_name, k_layer)
+    else
+      raise DNNKerasModelConvertError.new("#{k_layer_name} layer do not support convert.")
+    end
+  end
+
+  def get_k_layer_shape(k_layer)
+    input_shape = k_layer.input_shape.to_a[1..-1]
+    output_shape = k_layer.output_shape.to_a[1..-1]
+    [input_shape, output_shape]
+  end
+
+  def build_dnn_layer(k_layer, dnn_layer)
+    input_shape, output_shape = get_k_layer_shape(k_layer)
+    dnn_layer.build(input_shape)
+  end
+
+  def convert_Dense(k_dense)
+    input_shape, output_shape = get_k_layer_shape(k_dense)
+    dense = DNN::Layers::Dense.new(output_shape[0])
+    dense.build(input_shape)
+    dense.weight.data = Numpy.to_na(k_dense.get_weights[0])
+    dense.bias.data = Numpy.to_na(k_dense.get_weights[1])
+    dense
+  end
+
+  def convert_Activation(k_activation)
+    activation_name = k_activation.get_config[:activation].to_s
+    case k_activation.get_config[:activation].to_s
+    when "sigmoid"
+      activation = DNN::Layers::Sigmoid.new
+    when "tanh"
+      activation = DNN::Layers::Tanh.new
+    when "relu"
+      activation = DNN::Layers::ReLU.new
+    when "softmax"
+      return nil
+    else
+      raise DNNKerasModelConvertError.new("#{activation_name} activation do not support convert.")
+    end
+    build_dnn_layer(k_activation, activation)
+    activation
+  end
+
+  def convert_Dropout(k_dropout)
+    dropout_ratio = k_dropout.get_config[:rate]
+    dropout = DNN::Layers::Dropout.new(dropout_ratio, use_scale: false)
+    build_dnn_layer(k_dropout, dropout)
+    dropout
+  end
+
+  def convert_BatchNormalization(k_batch_norm)
+    momentum = k_batch_norm.get_config[momentum]
+    batch_norm = DNN::Layers::BatchNormalization.new(momentum: momentum)
+    build_dnn_layer(k_batch_norm, batch_norm)
+    batch_norm.gamma.data = Numpy.to_na(k_batch_norm.get_weights[0])
+    batch_norm.beta.data = Numpy.to_na(k_batch_norm.get_weights[1])
+    batch_norm.running_mean.data = Numpy.to_na(k_batch_norm.get_weights[2])
+    batch_norm.running_var.data = Numpy.to_na(k_batch_norm.get_weights[3])
+    batch_norm
+  end
+
+  def convert_Conv2D(k_conv2d)
+    padding = k_conv2d.get_config[:padding].to_s == "same" ? true : false
+    filter_size = k_conv2d.get_config[:kernel_size].to_a
+    strides = k_conv2d.get_config[:strides].to_a
+    num_filters = k_conv2d.get_config[:filters]
+    conv2d = DNN::Layers::Conv2D.new(num_filters, filter_size, padding: padding, strides: strides)
+    build_dnn_layer(k_conv2d, conv2d)
+    conv2d.filters = Numpy.to_na(k_conv2d.get_weights[0])
+    conv2d.bias.data = Numpy.to_na(k_conv2d.get_weights[1])
+    conv2d
+  end
+
+  def convert_Conv2DTranspose(k_conv2d)
+    padding = k_conv2d.get_config[:padding].to_s == "same" ? true : false
+    filter_size = k_conv2d.get_config[:kernel_size].to_a
+    strides = k_conv2d.get_config[:strides].to_a
+    num_filters = k_conv2d.get_config[:filters]
+    conv2d = DNN::Layers::Conv2DTranspose.new(num_filters, filter_size, padding: padding, strides: strides)
+    build_dnn_layer(k_conv2d, conv2d)
+    conv2d.filters = Numpy.to_na(k_conv2d.get_weights[0])
+    conv2d.bias.data = Numpy.to_na(k_conv2d.get_weights[1])
+    conv2d
+  end
+
+  def convert_MaxPooling2D(k_max_pool2d)
+    padding = k_max_pool2d.get_config[:padding].to_s == "same" ? true : false
+    pool_size = k_max_pool2d.get_config[:pool_size].to_a
+    strides = k_max_pool2d.get_config[:strides].to_a
+    max_pool2d = DNN::Layers::MaxPool2D.new(pool_size, padding: padding, strides: strides)
+    build_dnn_layer(k_max_pool2d, max_pool2d)
+    max_pool2d
+  end
+
+  def convert_UpSampling2D(k_upsampling2d)
+    input_shape, output_shape = get_k_layer_shape(k_upsampling2d)
+    unpool_size = k_upsampling2d.get_config[:size].to_a
+    unpool2d = DNN::Layers::UnPool2D.new(unpool_size)
+    build_dnn_layer(k_upsampling2d, unpool2d)
+    unpool2d
+  end
+
+  def convert_Flatten(k_flatten)
+    flatten = DNN::Layers::Flatten.new
+    build_dnn_layer(k_flatten, flatten)
+    flatten
+  end
+
+  def convert_Reshape(k_reshape)
+    input_shape, output_shape = get_k_layer_shape(k_reshape)
+    reshape = DNN::Layers::Reshape.new(output_shape)
+    build_dnn_layer(k_reshape, reshape)
+    reshape
+  end
+end

data/lib/dnn/numo2numpy.rb

@@ -0,0 +1,72 @@
+# This library is a performs mutual conversion between Numo and Numpy.
+# You need to install PyCall to use this library.
+# [Usage]
+# numpy to numo: Numpy.to_na(np_array)
+# numo to numpy: Numpy.from_na(narray)
+
+require "pycall/import"
+require "numpy"
+
+include PyCall::Import
+
+class NumpyToNumoError < StandardError; end
+
+module Numpy
+  def self.from_na(narray)
+    bin = narray.to_binary
+    bin.force_encoding("ASCII-8BIT")
+    case
+    when narray.is_a?(Numo::Int8)
+      Numpy.frombuffer(bin, dtype: "int8").reshape(*narray.shape)
+    when narray.is_a?(Numo::UInt8)
+      Numpy.frombuffer(bin, dtype: "uint8").reshape(*narray.shape)
+    when narray.is_a?(Numo::Int16)
+      Numpy.frombuffer(bin, dtype: "int16").reshape(*narray.shape)
+    when narray.is_a?(Numo::UInt16)
+      Numpy.frombuffer(bin, dtype: "uint16").reshape(*narray.shape)
+    when narray.is_a?(Numo::Int32)
+      Numpy.frombuffer(bin, dtype: "int32").reshape(*narray.shape)
+    when narray.is_a?(Numo::UInt32)
+      Numpy.frombuffer(bin, dtype: "uint32").reshape(*narray.shape)
+    when narray.is_a?(Numo::Int64)
+      Numpy.frombuffer(bin, dtype: "int64").reshape(*narray.shape)
+    when narray.is_a?(Numo::UInt64)
+      Numpy.frombuffer(bin, dtype: "uint64").reshape(*narray.shape)
+    when narray.is_a?(Numo::SFloat)
+      Numpy.frombuffer(bin, dtype: "float32").reshape(*narray.shape)
+    when narray.is_a?(Numo::DFloat)
+      Numpy.frombuffer(bin, dtype: "float64").reshape(*narray.shape)
+    else
+      raise NumpyToNumoError.new("#{narray.class.name} is not support convert.")
+    end
+  end
+
+  def self.to_na(ndarray)
+    shape = ndarray.shape
+    bin = ndarray.flatten.tobytes
+    case ndarray.dtype.to_s
+    when "int8"
+      Numo::Int8.from_binary(bin).reshape(*shape)
+    when "uint8"
+      Numo::UInt8.from_binary(bin).reshape(*shape)
+    when "int16"
+      Numo::Int16.from_binary(bin).reshape(*shape)
+    when "uint16"
+      Numo::UInt16.from_binary(bin).reshape(*shape)
+    when "int32"
+      Numo::Int32.from_binary(bin).reshape(*shape)
+    when "uint32"
+      Numo::UInt32.from_binary(bin).reshape(*shape)
+    when "int64"
+      Numo::Int64.from_binary(bin).reshape(*shape)
+    when "uint64"
+      Numo::UInt64.from_binary(bin).reshape(*shape)
+    when "float32"
+      Numo::SFloat.from_binary(bin).reshape(*shape)
+    when "float64"
+      Numo::DFloat.from_binary(bin).reshape(*shape)
+    else
+      raise NumpyToNumoError.new("#{ndarray.dtype} is not support convert.")
+    end
+  end
+end

data/lib/dnn/version.rb

@@ -1,3 +1,3 @@
 module DNN
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dnn
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - unagiootoro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-13 00:00:00.000000000 Z
+date: 2020-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -150,6 +150,8 @@ files:
 - lib/dnn/datasets/mnist.rb
 - lib/dnn/datasets/stl-10.rb
 - lib/dnn/image.rb
+- lib/dnn/keras-model-convertor.rb
+- lib/dnn/numo2numpy.rb
 - lib/dnn/version.rb
 - ruby-dnn.gemspec
 - third_party/stb_image.h