ruby-dnn 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97822807b84847cb2ad475bef5dd65329ae0c699847c577eb8b30a2be0425ec0
-  data.tar.gz: 6871849ea256e466f4d10e354c5e7698247be8328c17e540e5d4b35adf46ee27
+  metadata.gz: 41b7dde05615d65bbc09fec893f67c0874a44aaff4dff8243c9ccdf97f5c9d7a
+  data.tar.gz: fea5cb29b787d4cbbba18f34ab2f3f4e6275f8018ebda6c335c9f3564194b109
 SHA512:
-  metadata.gz: aa8fb779d8cec6e4acd1ce63a952f626eceae801ee7e16045a890412d8b9189e95d3798c9d840ab07de4afe517ebeac9230391e193b24cedb316927bda4726c9
-  data.tar.gz: 16aa82f8e009eca027e693adb3fb543046376f11539b881a65ef29dd484b8225b34c17ee3171d72a6a9b2a3712b8463630deac778f1a851830df6ed53b7feca8
+  metadata.gz: c18e653840184c9590966b18f36a98a843cf2d1d6ced1159c071ca21839476e4d6f0b6b36bb5319414a50c430cef8a1dd66bedc0ab87d16602896dff6006bc2e
+  data.tar.gz: ec7844e9a5bae664e8a5dd88d5684731c2a2bd3149c8131b8cbe606a9e10c30a68f7f8c4904644f931d2616cdc19dc345254934b792df4eb94117ab31c9b06f2

data/README.md

@@ -95,6 +95,8 @@ If you want to know more detailed information, please refer to the source code.
 | Losses | MeanSquaredError, MeanAbsoluteError, Hinge, HuberLoss, SoftmaxCrossEntropy, SigmoidCrossEntropy |
 
 ## Datasets
+By setting the environment variable "RUBY_DNN_DOWNLOADS_PATH", you can specify the path to read dataset.
+
 ● Iris  
 ● MNIST  
 ● Fashion-MNIST  

data/examples/pix2pix/dcgan.rb

@@ -2,8 +2,6 @@ include DNN::Models
 include DNN::Layers
 
 class Generator < Model
-  attr_reader :generate_images
-
   def initialize(input_shape)
     super()
     @input_shape = input_shape
@@ -27,7 +25,6 @@ class Generator < Model
     @bn7 = BatchNormalization.new
     @bn8 = BatchNormalization.new
     @bn9 = BatchNormalization.new
-    @generate_images = nil
   end
 
   def forward(x)
@@ -75,7 +72,6 @@ class Generator < Model
 
     x = @l11.(x)
     x = Tanh.(x)
-    @generate_images = x.data
     x
   end
 end
@@ -162,9 +158,9 @@ class DCGAN < Model
   end
 
   def forward(input)
-    x = @gen.(input)
+    images = @gen.(input)
     @dis.disable_training
-    x = @dis.([input, x])
-    x
+    out = @dis.([input, images])
+    [images, out]
   end
 end

data/examples/pix2pix/train.rb

@@ -17,28 +17,35 @@ def load_dataset
   [x_in, x_out]
 end
 
+initial_epoch = 1
+
 epochs = 20
 batch_size = 128
 
-gen = Generator.new([32, 32, 1])
-dis = Discriminator.new([32, 32, 1], [32, 32, 3])
-dcgan = DCGAN.new(gen, dis)
-
-gen.setup(Adam.new(alpha: 0.0002, beta1: 0.5), MeanAbsoluteError.new)
-dis.setup(Adam.new(alpha: 0.00001, beta1: 0.1), SigmoidCrossEntropy.new)
-dcgan.setup(Adam.new(alpha: 0.0002, beta1: 0.5), SigmoidCrossEntropy.new)
+if initial_epoch == 1
+  gen = Generator.new([32, 32, 1])
+  dis = Discriminator.new([32, 32, 1], [32, 32, 3])
+  dcgan = DCGAN.new(gen, dis)
+  gen.setup(Adam.new(alpha: 0.0002, beta1: 0.5), MeanAbsoluteError.new)
+  dis.setup(Adam.new(alpha: 0.00001, beta1: 0.1), SigmoidCrossEntropy.new)
+  dcgan.setup(Adam.new(alpha: 0.0002, beta1: 0.5),
+              [MeanAbsoluteError.new, SigmoidCrossEntropy.new], loss_weights: [10, 1])
+else
+  dcgan = DCGAN.load("trained/dcgan_model_epoch#{initial_epoch - 1}.marshal")
+  gen = dcgan.gen
+  dis = dcgan.dis
+end
 
 x_in, x_out = load_dataset
 
 iter1 = DNN::Iterator.new(x_in, x_out)
 iter2 = DNN::Iterator.new(x_in, x_out)
 num_batchs = x_in.shape[0] / batch_size
-(1..epochs).each do |epoch|
+(initial_epoch..epochs).each do |epoch|
   num_batchs.times do |index|
     x_in, x_out = iter1.next_batch(batch_size)
-    gen_loss = gen.train_on_batch(x_in, x_out)
 
-    images = gen.generate_images
+    images = gen.predict(x_in)
     y_real = Numo::SFloat.ones(batch_size, 1)
     y_fake = Numo::SFloat.zeros(batch_size, 1)
     dis.enable_training
@@ -46,9 +53,9 @@ num_batchs = x_in.shape[0] / batch_size
     dis_loss += dis.train_on_batch([x_in, images], y_fake)
 
     x_in, x_out = iter2.next_batch(batch_size)
-    dcgan_loss = dcgan.train_on_batch(x_in, y_real)
+    dcgan_loss = dcgan.train_on_batch(x_in, [x_out, y_real])
 
-    puts "epoch: #{epoch}, index: #{index}, gen_loss: #{gen_loss}, dis_loss: #{dis_loss}, dcgan_loss: #{dcgan_loss}"
+    puts "epoch: #{epoch}, index: #{index}, dis_loss: #{dis_loss}, dcgan_loss: #{dcgan_loss}"
   end
   iter1.reset
   iter2.reset

data/lib/dnn/core/losses.rb

@@ -19,11 +19,12 @@ module DNN
         forward(y, t)
       end
 
-      def loss(y, t, layers = nil)
+      def loss(y, t, layers: nil, loss_weight: nil)
         unless y.shape == t.shape
           raise DNNShapeError, "The shape of y does not match the t shape. y shape is #{y.shape}, but t shape is #{t.shape}."
         end
         loss = call(y, t)
+        loss *= loss_weight if loss_weight
         loss = regularizers_forward(loss, layers) if layers
         loss
       end

data/lib/dnn/core/models.rb

@@ -109,6 +109,7 @@ module DNN
     # This class deals with the model of the network.
     class Model < Chain
       attr_accessor :optimizer
+      attr_accessor :loss_weights
       attr_reader :last_log
 
       # Load marshal model.
@@ -126,6 +127,7 @@ module DNN
         @optimizer = nil
         @loss_func = nil
         @built = false
+        @loss_weights = nil
         @callbacks = []
         @last_log = {}
       end
@@ -139,7 +141,8 @@ module DNN
       # Set optimizer and loss_func to model.
       # @param [DNN::Optimizers::Optimizer] optimizer Optimizer to use for learning.
       # @param [DNN::Losses::Loss] loss_func Loss function to use for learning.
-      def setup(optimizer, loss_func)
+      # @param [Array | NilClass] loss_weights Setting loss weights contribution.
+      def setup(optimizer, loss_func, loss_weights: nil)
         unless optimizer.is_a?(Optimizers::Optimizer)
           raise TypeError, "optimizer:#{optimizer.class} is not an instance of DNN::Optimizers::Optimizer class."
         end
@@ -148,6 +151,7 @@ module DNN
         end
         @optimizer = optimizer
         self.loss_func = loss_func
+        @loss_weights = loss_weights
       end
 
       def loss_func
@@ -178,18 +182,21 @@ module DNN
       # @param [Array | NilClass] test If you to test the model for every 1 epoch,
       #                                specify [x_test, y_test]. Don't test to the model, specify nil.
       # @param [Boolean] verbose Set true to display the log. If false is set, the log is not displayed.
+      # @param [Boolean] accuracy Set true to compute the accuracy.
       def train(x, y, epochs,
                 batch_size: 1,
                 initial_epoch: 1,
                 test: nil,
-                verbose: true)
+                verbose: true,
+                accuracy: true)
         check_xy_type(x, y)
         train_iterator = Iterator.new(x, y)
         train_by_iterator(train_iterator, epochs,
                           batch_size: batch_size,
                           initial_epoch: initial_epoch,
                           test: test,
-                          verbose: verbose)
+                          verbose: verbose,
+                          accuracy: accuracy)
       end
 
       alias fit train
@@ -203,11 +210,13 @@ module DNN
       # @param [Array | NilClass] test If you to test the model for every 1 epoch,
       #                                specify [x_test, y_test]. Don't test to the model, specify nil.
       # @param [Boolean] verbose Set true to display the log. If false is set, the log is not displayed.
+      # @param [Boolean] accuracy Set true to compute the accuracy.
       def train_by_iterator(train_iterator, epochs,
                             batch_size: 1,
                             initial_epoch: 1,
                             test: nil,
-                            verbose: true)
+                            verbose: true,
+                            accuracy: true)
         raise DNNError, "The model is not optimizer setup complete." unless @optimizer
         raise DNNError, "The model is not loss_func setup complete." unless @loss_func
 
@@ -242,11 +251,18 @@ module DNN
 
             if test
               acc, loss = if test.is_a?(Array)
-                            evaluate(test[0], test[1], batch_size: batch_size)
+                            evaluate(test[0], test[1], batch_size: batch_size, accuracy: accuracy)
                           else
-                            evaluate_by_iterator(test, batch_size: batch_size)
+                            evaluate_by_iterator(test, batch_size: batch_size, accuracy: accuracy)
                           end
-              print "  " + metrics_to_str({ accuracy: acc, test_loss: loss }) if verbose
+              if verbose
+                metrics = if accuracy
+                            { accuracy: acc, test_loss: loss }
+                          else
+                            { test_loss: loss }
+                          end
+                print "  " + metrics_to_str(metrics)
+              end
             end
             puts "" if verbose
             call_callbacks(:after_epoch)
@@ -285,17 +301,16 @@ module DNN
         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_opt = {}
+            loss_opt[:layers] = layers if i == 0
+            loss_opt[:loss_weight] = @loss_weights[i] if @loss_weights
+            loss = @loss_func[i].loss(out, Tensor.convert(y[i]), **loss_opt)
             loss_data << loss.data.to_f
             loss.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 = @loss_func.loss(out, Tensor.convert(y), layers: layers)
           loss_data = loss.data.to_f
           loss.link.backward(Xumo::SFloat.ones(y[0...1, false].shape[0], 1))
         end
@@ -310,16 +325,18 @@ module DNN
       # @param [Numo::SFloat] y Output test data.
       # @param [Integer] batch_size Batch size used for one test.
       # @return [Array] Returns the test data accuracy and mean loss in the form [accuracy, mean_loss].
-      def evaluate(x, y, batch_size: 100)
+      #                 If accuracy is not needed returns in the form [nil, mean_loss].
+      def evaluate(x, y, batch_size: 100, accuracy: true)
         check_xy_type(x, y)
-        evaluate_by_iterator(Iterator.new(x, y, random: false), batch_size: batch_size)
+        evaluate_by_iterator(Iterator.new(x, y, random: false), batch_size: batch_size, accuracy: accuracy)
       end
 
       # Evaluate model by iterator.
       # @param [DNN::Iterator] test_iterator Iterator used for testing.
       # @param [Integer] batch_size Batch size used for one test.
       # @return [Array] Returns the test data accuracy and mean loss in the form [accuracy, mean_loss].
-      def evaluate_by_iterator(test_iterator, batch_size: 100)
+      #                 If accuracy is not needed returns in the form [nil, mean_loss].
+      def evaluate_by_iterator(test_iterator, batch_size: 100, accuracy: true)
         num_test_datas = test_iterator.num_datas
         batch_size = batch_size >= num_test_datas ? num_test_datas : batch_size
         if @loss_func.is_a?(Array)
@@ -331,27 +348,28 @@ module DNN
         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)
+          correct, loss_value = test_on_batch(x_batch, y_batch, accuracy: accuracy)
           if @loss_func.is_a?(Array)
             @loss_func.each_index do |i|
-              total_correct[i] += correct[i]
+              total_correct[i] += correct[i] if accuracy
               sum_loss[i] += loss_value[i]
             end
           else
-            total_correct += correct
+            total_correct += correct if accuracy
             sum_loss += loss_value
           end
         end
+        acc = nil
         if @loss_func.is_a?(Array)
           mean_loss = Array.new(@loss_func.length, 0)
-          acc = Array.new(@loss_func.length, 0)
+          acc = Array.new(@loss_func.length, 0) if accuracy
           @loss_func.each_index do |i|
             mean_loss[i] += sum_loss[i] / max_steps
-            acc[i] += total_correct[i].to_f / num_test_datas
+            acc[i] += total_correct[i].to_f / num_test_datas if accuracy
           end
         else
           mean_loss = sum_loss / max_steps
-          acc = total_correct.to_f / num_test_datas
+          acc = total_correct.to_f / num_test_datas if accuracy
         end
         @last_log[:test_loss] = mean_loss
         @last_log[:test_accuracy] = acc
@@ -361,22 +379,24 @@ module DNN
       # Evaluate once.
       # @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)
+      # @return [Array] Returns the test data accuracy and mean loss in the form [accuracy, loss].
+      #                 If accuracy is not needed returns in the form [nil, loss].
+      def test_on_batch(x, y, accuracy: true)
         call_callbacks(:before_test_on_batch)
         DNN.learning_phase = false
         output_tensors = call(Tensor.convert(x))
+        correct = nil
         if output_tensors.is_a?(Array)
-          correct = []
+          correct = [] if accuracy
           loss_data = []
           output_tensors.each.with_index do |out, i|
-            correct << accuracy(out.data, y[i])
+            correct << accuracy(out.data, y[i]) if accuracy
             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)
+          correct = accuracy(out.data, y) if accuracy
           loss = @loss_func.(out, Tensor.convert(y))
           loss_data = loss.data.to_f
         end

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

@@ -27,36 +27,51 @@ end
 
 class DNNKerasModelConvertError < DNN::DNNError; end
 
+class DNNKerasLayerNotConvertSupportError < DNNKerasModelConvertError; 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
+  def self.load(k_model_name, k_weights_name = nil)
+    k_model = load_model(k_model_name)
+    k_model.load_weights(k_weights_name) if k_weights_name
+    self.new(k_model)
   end
 
-  def initialize(k_model_name, k_weights_name = nil)
-    @k_model = KerasModelConvertor.k_load_model(k_model_name, k_weights_name)
+  def initialize(k_model)
+    @k_model = k_model
   end
 
-  def convert
+  def convert(not_support_to_nil: false, debug_message: false)
     unless @k_model.__class__.__name__ == "Sequential"
       raise DNNKerasModelConvertError.new("#{@k_model.__class__.__name__} models do not support convert.")
     end
-    layers = convert_layers(@k_model.layers)
-    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)
-    layers.unshift(input_layer)
+    layers = convert_layers(not_support_to_nil: not_support_to_nil, debug_message: debug_message)
     dnn_model = DNN::Models::Sequential.new(layers)
     dnn_model
   end
 
-  def convert_layers(k_layers)
-    k_layers.map do |k_layer|
-      layer_convert(k_layer)
+  def convert_layers(not_support_to_nil: false, debug_message: false)
+    layers = []
+    @k_model.layers.each do |k_layer|
+      layer = if not_support_to_nil
+        begin
+          layer_convert(k_layer)
+        rescue DNNKerasLayerNotConvertSupportError => e
+          nil
+        end
+      else
+        layer_convert(k_layer)
+      end
+      if layer.is_a?(Array)
+        layer.each { |l| puts "Converted #{l.class.name} layer" } if debug_message
+        layers += layer
+      else
+        puts "Converted #{layer.class.name} layer" if debug_message
+        layers << layer
+      end
     end
+    layers
   end
 
   private
@@ -67,7 +82,7 @@ class KerasModelConvertor
     if respond_to?(method_name, true)
       send(method_name, k_layer)
     else
-      raise DNNKerasModelConvertError.new("#{k_layer_name} layer do not support convert.")
+      raise DNNKerasLayerNotConvertSupportError.new("#{k_layer_name} layer do not support convert.")
     end
   end
 
@@ -82,18 +97,34 @@ class KerasModelConvertor
     dnn_layer.build(input_shape)
   end
 
+  def convert_InputLayer(k_input_layer)
+    input_shape, output_shape = get_k_layer_shape(k_input_layer)
+    input_layer = DNN::Layers::InputLayer.new(input_shape)
+    input_layer.build(input_shape)
+    input_layer
+  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
+    returns = [dense]
+    unless k_dense.get_config[:activation] == "linear"
+      returns << activation_to_dnn_layer(k_dense.get_config[:activation], output_shape)
+    end
+    returns
   end
 
   def convert_Activation(k_activation)
+    input_shape, output_shape = get_k_layer_shape(k_activation)
     activation_name = k_activation.get_config[:activation].to_s
-    activation = case k_activation.get_config[:activation].to_s
+    activation_to_dnn_layer(activation_name, input_shape)
+  end
+
+  def activation_to_dnn_layer(activation_name, shape)
+    activation = case activation_name
     when "sigmoid"
        DNN::Layers::Sigmoid.new
     when "tanh"
@@ -105,7 +136,7 @@ class KerasModelConvertor
     else
       raise DNNKerasModelConvertError.new("#{activation_name} activation do not support convert.")
     end
-    build_dnn_layer(k_activation, activation)
+    activation.build(shape)
     activation
   end
 
@@ -136,19 +167,29 @@ class KerasModelConvertor
     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
+    returns = [conv2d]
+    unless k_conv2d.get_config[:activation] == "linear"
+      input_shape, output_shape = get_k_layer_shape(k_conv2d)
+      returns << activation_to_dnn_layer(k_conv2d.get_config[:activation], output_shape)
+    end
+    returns
+  end
+
+  def convert_Conv2DTranspose(k_conv2d_t)
+    padding = k_conv2d_t.get_config[:padding].to_s == "same" ? true : false
+    filter_size = k_conv2d_t.get_config[:kernel_size].to_a
+    strides = k_conv2d_t.get_config[:strides].to_a
+    num_filters = k_conv2d_t.get_config[:filters]
+    conv2d_t = DNN::Layers::Conv2DTranspose.new(num_filters, filter_size, padding: padding, strides: strides)
+    build_dnn_layer(k_conv2d_t, conv2d_t)
+    conv2d_t.filters = Numpy.to_na(k_conv2d_t.get_weights[0])
+    conv2d_t.bias.data = Numpy.to_na(k_conv2d_t.get_weights[1])
+    returns = [conv2d_t]
+    unless conv2d_t.get_config[:activation] == "linear"
+      input_shape, output_shape = get_k_layer_shape(k_conv2d)
+      returns << activation_to_dnn_layer(conv2d_t.get_config[:activation], output_shape)
+    end
+    returns
   end
 
   def convert_MaxPooling2D(k_max_pool2d)
@@ -160,6 +201,24 @@ class KerasModelConvertor
     max_pool2d
   end
 
+  def convert_AveragePooling2D(k_avg_pool2d)
+    padding = k_avg_pool2d.get_config[:padding].to_s == "same" ? true : false
+    pool_size = k_avg_pool2d.get_config[:pool_size].to_a
+    strides = k_avg_pool2d.get_config[:strides].to_a
+    avg_pool2d = DNN::Layers::AvgPool2D.new(pool_size, padding: padding, strides: strides)
+    build_dnn_layer(k_avg_pool2d, avg_pool2d)
+    avg_pool2d
+  end
+
+  def convert_GlobalAveragePooling2D(k_glb_avg_pool2d)
+    padding = k_glb_avg_pool2d.get_config[:padding].to_s == "same" ? true : false
+    pool_size = k_glb_avg_pool2d.get_config[:pool_size].to_a
+    strides = k_glb_avg_pool2d.get_config[:strides].to_a
+    glb_avg_pool2d = DNN::Layers::GlobalAvgPool2D.new
+    build_dnn_layer(k_glb_avg_pool2d, glb_avg_pool2d)
+    glb_avg_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

data/lib/dnn/version.rb

@@ -1,3 +1,3 @@
 module DNN
-  VERSION = "1.1.1"
+  VERSION = "1.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dnn
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
 platform: ruby
 authors:
 - unagiootoro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-09 00:00:00.000000000 Z
+date: 2020-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray