ruby-dnn 1.1.4 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d33f1d5472229d184630d37063d4c42888230044a9e1b069035a144e8aae0964
-  data.tar.gz: 530d31b5fc5073fa02253eb0f7d7b78a007ccaed16ea4a49aba56a87174afb59
+  metadata.gz: 55dea04f1d2a6bb4806c3f029086474b46b8a225f7168e4c72af92e0f7d69f71
+  data.tar.gz: 2522778ffabbce31315b48ad3abfedd2dea2e9dba0d09af4e9700cb9c588393b
 SHA512:
-  metadata.gz: acf104aec7d661da52623930dbd8a60e105aff6b0c7fd4bdc675f507a50f55372451d7c4066992d13a390629d89ec7ba42d7c316376797e439e6b399d702e5aa
-  data.tar.gz: 1e338be765295d9c9827dc82c70e7af79473386be1574ae647ef2568c24be9f9142d94104b62726bda800aff064c37ede794066cfb098a40744dd24a2e7addb4
+  metadata.gz: 05056e7619f52dd8efac34c6aeae1e1652e3635257baf302f15908131d6908d7ee49e892040514b0ea3011c46148eb3c0fedd3857b85ab0cf271c521bb907349
+  data.tar.gz: 41828ada6a07129fdfc4ed5aff6af9c6dc7d934dd0f39eec8792d77a7b2fc5769b2f3d278ced6b5def360db58a7a34c014a0876e65ca7525d35a67219285aab7

data/README.md

@@ -54,18 +54,18 @@ When create a model with 'define by run' style:
 class MLP < Model
   def initialize
     super
-    @l1 = Dense.new(256)
-    @l2 = Dense.new(256)
-    @l3 = Dense.new(10)
+    @d1 = Dense.new(256)
+    @d2 = Dense.new(256)
+    @d3 = Dense.new(10)
   end
 
   def forward(x)
     x = InputLayer.new(784).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = ReLU.(x)
-    x = @l2.(x)
+    x = @d2.(x)
     x = ReLU.(x)
-    x = @l3.(x)
+    x = @d3.(x)
     x
   end
 end

data/examples/api-examples/early_stopping_example.rb

@@ -27,22 +27,22 @@ y_test = DNN::Utils.to_categorical(y_test, 10, Numo::SFloat)
 class MLP < Model
   def initialize
     super
-    @l1 = Dense.new(256)
-    @l2 = Dense.new(256)
-    @l3 = Dense.new(10)
+    @d1 = Dense.new(256)
+    @d2 = Dense.new(256)
+    @d3 = Dense.new(10)
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
   end
 
   def forward(x)
     x = InputLayer.new(784).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = @bn1.(x)
     x = ReLU.(x)
-    x = @l2.(x)
+    x = @d2.(x)
     x = @bn2.(x)
     x = ReLU.(x)
-    x = @l3.(x)
+    x = @d3.(x)
     x
   end
 end

data/examples/api-examples/initializer_example.rb

@@ -28,22 +28,22 @@ class MLP < Model
   def initialize
     super
     # Set the initial values of weight and bias to the initial values of He.
-    @l1 = Dense.new(256, weight_initializer: He.new, bias_initializer: He.new)
-    @l2 = Dense.new(256, weight_initializer: He.new, bias_initializer: He.new)
-    @l3 = Dense.new(10, weight_initializer: He.new, bias_initializer: He.new)
+    @d1 = Dense.new(256, weight_initializer: He.new, bias_initializer: He.new)
+    @d2 = Dense.new(256, weight_initializer: He.new, bias_initializer: He.new)
+    @d3 = Dense.new(10, weight_initializer: He.new, bias_initializer: He.new)
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
   end
 
   def forward(x)
     x = InputLayer.new(784).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = @bn1.(x)
     x = ReLU.(x)
-    x = @l2.(x)
+    x = @d2.(x)
     x = @bn2.(x)
     x = ReLU.(x)
-    x = @l3.(x)
+    x = @d3.(x)
     x
   end
 end

data/examples/api-examples/regularizer_example.rb

@@ -29,22 +29,22 @@ class MLP < Model
   def initialize
     super
     # Set L2 regularizer(weight decay) for weight and bias.
-    @l1 = Dense.new(256, weight_regularizer: L2.new(L2_LAMBDA), bias_regularizer: L2.new(L2_LAMBDA))
-    @l2 = Dense.new(256, weight_regularizer: L2.new(L2_LAMBDA), bias_regularizer: L2.new(L2_LAMBDA))
-    @l3 = Dense.new(10, weight_regularizer: L2.new(L2_LAMBDA), bias_regularizer: L2.new(L2_LAMBDA))
+    @d1 = Dense.new(256, weight_regularizer: L2.new(L2_LAMBDA), bias_regularizer: L2.new(L2_LAMBDA))
+    @d2 = Dense.new(256, weight_regularizer: L2.new(L2_LAMBDA), bias_regularizer: L2.new(L2_LAMBDA))
+    @d3 = Dense.new(10, weight_regularizer: L2.new(L2_LAMBDA), bias_regularizer: L2.new(L2_LAMBDA))
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
   end
 
   def forward(x)
     x = InputLayer.new(784).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = @bn1.(x)
     x = ReLU.(x)
-    x = @l2.(x)
+    x = @d2.(x)
     x = @bn2.(x)
     x = ReLU.(x)
-    x = @l3.(x)
+    x = @d3.(x)
     x
   end
 end

data/examples/api-examples/save_example.rb

@@ -38,22 +38,22 @@ y_test = DNN::Utils.to_categorical(y_test, 10, Numo::SFloat)
 class MLP < Model
   def initialize
     super
-    @l1 = Dense.new(256)
-    @l2 = Dense.new(256)
-    @l3 = Dense.new(10)
+    @d1 = Dense.new(256)
+    @d2 = Dense.new(256)
+    @d3 = Dense.new(10)
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
   end
 
   def forward(x)
     x = InputLayer.new(784).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = @bn1.(x)
     x = ReLU.(x)
-    x = @l2.(x)
+    x = @d2.(x)
     x = @bn2.(x)
     x = ReLU.(x)
-    x = @l3.(x)
+    x = @d3.(x)
     x
   end
 end

data/examples/dcgan/dcgan.rb

@@ -4,13 +4,13 @@ include DNN::Layers
 class Generator < Model
   def initialize
     super
-    @l1 = Dense.new(1024)
-    @l2 = Dense.new(7 * 7 * 64)
-    @l3 = Conv2DTranspose.new(64, 4, strides: 2, padding: true)
-    @l4 = Conv2D.new(64, 4, padding: true)
-    @l5 = Conv2DTranspose.new(32, 4, strides: 2, padding: true)
-    @l6 = Conv2D.new(32, 4, padding: true)
-    @l7 = Conv2D.new(1, 4, padding: true)
+    @d1 = Dense.new(1024)
+    @d2 = Dense.new(7 * 7 * 64)
+    @cv1 = Conv2D.new(64, 4, padding: true)
+    @cvt1 = Conv2DTranspose.new(64, 4, strides: 2, padding: true)
+    @cvt2 = Conv2DTranspose.new(32, 4, strides: 2, padding: true)
+    @cv2 = Conv2D.new(32, 4, padding: true)
+    @cv3 = Conv2D.new(1, 4, padding: true)
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
     @bn3 = BatchNormalization.new
@@ -21,32 +21,32 @@ class Generator < Model
 
   def forward(x)
     x = InputLayer.new(20).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = @bn1.(x)
     x = ReLU.(x)
 
-    x = @l2.(x)
+    x = @d2.(x)
     x = @bn2.(x)
     x = ReLU.(x)
 
     x = Reshape.(x, [7, 7, 64])
-    x = @l3.(x)
+    x = @cvt1.(x)
     x = @bn3.(x)
     x = ReLU.(x)
 
-    x = @l4.(x)
+    x = @cv1.(x)
     x = @bn4.(x)
     x = ReLU.(x)
 
-    x = @l5.(x)
+    x = @cvt2.(x)
     x = @bn5.(x)
     x = ReLU.(x)
 
-    x = @l6.(x)
+    x = @cv2.(x)
     x = @bn6.(x)
     x = ReLU.(x)
 
-    x = @l7.(x)
+    x = @cv3.(x)
     x = Tanh.(x)
     x
   end
@@ -55,12 +55,12 @@ end
 class Discriminator < Model
   def initialize
     super
-    @l1 = Conv2D.new(32, 4, strides: 2, padding: true)
-    @l2 = Conv2D.new(32, 4, padding: true)
-    @l3 = Conv2D.new(64, 4, strides: 2, padding: true)
-    @l4 = Conv2D.new(64, 4, padding: true)
-    @l5 = Dense.new(1024)
-    @l6 = Dense.new(1)
+    @cv1 = Conv2D.new(32, 4, strides: 2, padding: true)
+    @cv2 = Conv2D.new(32, 4, padding: true)
+    @cv3 = Conv2D.new(64, 4, strides: 2, padding: true)
+    @cv4 = Conv2D.new(64, 4, padding: true)
+    @d1 = Dense.new(1024)
+    @d2 = Dense.new(1)
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
     @bn3 = BatchNormalization.new
@@ -68,26 +68,26 @@ class Discriminator < Model
 
   def forward(x)
     x = InputLayer.new([28, 28, 1]).(x)
-    x = @l1.(x)
+    x = @cv1.(x)
     x = LeakyReLU.(x, 0.2)
 
-    x = @l2.(x)
+    x = @cv2.(x)
     x = @bn1.(x)
     x = LeakyReLU.(x, 0.2)
 
-    x = @l3.(x)
+    x = @cv3.(x)
     x = @bn2.(x)
     x = LeakyReLU.(x, 0.2)
 
-    x = @l4.(x)
+    x = @cv4.(x)
     x = @bn3.(x)
     x = LeakyReLU.(x, 0.2)
 
     x = Flatten.(x)
-    x = @l5.(x)
+    x = @d1.(x)
     x = LeakyReLU.(x, 0.2)
 
-    x = @l6.(x)
+    x = @d2.(x)
     x
   end
 

data/examples/mnist_define_by_run.rb

@@ -1,7 +1,7 @@
 require "dnn"
 require "dnn/datasets/mnist"
 # If you use numo/linalg then please uncomment out.
-require "numo/linalg/autoloader"
+# require "numo/linalg/autoloader"
 
 include DNN::Models
 include DNN::Layers
@@ -23,18 +23,18 @@ y_test = DNN::Utils.to_categorical(y_test, 10, Numo::SFloat)
 class MLP < Model
   def initialize
     super
-    @l1 = Dense.new(256)
-    @l2 = Dense.new(256)
-    @l3 = Dense.new(10)
+    @d1 = Dense.new(256)
+    @d2 = Dense.new(256)
+    @d3 = Dense.new(10)
   end
 
   def forward(x)
     x = InputLayer.new(784).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = ReLU.(x)
-    x = @l2.(x)
+    x = @d2.(x)
     x = ReLU.(x)
-    x = @l3.(x)
+    x = @d3.(x)
     x
   end
 end

data/examples/pix2pix/dcgan.rb

@@ -2,20 +2,19 @@ include DNN::Models
 include DNN::Layers
 
 class Generator < Model
-  def initialize(input_shape)
+  def initialize(input_shape, base_num_filters)
     super()
     @input_shape = input_shape
-    @l1 = Conv2D.new(32, 4, padding: true)
-    @l2 = Conv2D.new(32, 4, strides: 2, padding: true)
-    @l3 = Conv2D.new(64, 4, padding: true)
-    @l4 = Conv2D.new(64, 4, strides: 2, padding: true)
-    @l5 = Conv2D.new(128, 4, padding: true)
-    @l6 = Conv2DTranspose.new(64, 4, strides: 2, padding: true)
-    @l7 = Conv2D.new(64, 4, padding: true)
-    @l8 = Conv2DTranspose.new(32, 4, strides: 2, padding: true)
-    @l9 = Conv2D.new(32, 4, padding: true)
-    @l10 = Conv2D.new(32, 4, padding: true)
-    @l11 = Conv2D.new(3, 4, padding: true)
+    @cv1 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv2 = Conv2D.new(base_num_filters, 4, strides: 2, padding: true)
+    @cv3 = Conv2D.new(base_num_filters * 2, 4, padding: true)
+    @cv4 = Conv2D.new(base_num_filters * 2, 4, strides: 2, padding: true)
+    @cv5 = Conv2D.new(base_num_filters * 2, 4, padding: true)
+    @cv6 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv7 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv8 = Conv2D.new(3, 4, padding: true)
+    @cvt1 = Conv2DTranspose.new(base_num_filters * 2, 4, strides: 2, padding: true)
+    @cvt2 = Conv2DTranspose.new(base_num_filters, 4, strides: 2, padding: true)
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
     @bn3 = BatchNormalization.new
@@ -24,53 +23,48 @@ class Generator < Model
     @bn6 = BatchNormalization.new
     @bn7 = BatchNormalization.new
     @bn8 = BatchNormalization.new
-    @bn9 = BatchNormalization.new
   end
 
   def forward(x)
     input = InputLayer.new(@input_shape).(x)
-    x = @l1.(input)
+    x = @cv1.(input)
     x = @bn1.(x)
-    h1 = ReLU.(x)
+    h1 = LeakyReLU.(x, 0.2)
 
-    x = @l2.(h1)
+    x = @cv2.(h1)
     x = @bn2.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l3.(x)
+    x = @cv3.(x)
     x = @bn3.(x)
-    h2 = ReLU.(x)
+    h2 = LeakyReLU.(x, 0.2)
 
-    x = @l4.(x)
+    x = @cv4.(h2)
     x = @bn4.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l5.(x)
+    x = @cv5.(x)
     x = @bn5.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l6.(x)
+    x = @cvt1.(x)
     x = @bn6.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
+    x = Concatenate.(x, h2, axis: 3)
 
-    x = @l7.(x)
+    x = @cv6.(x)
     x = @bn7.(x)
-    x = ReLU.(x)
-    x = Concatenate.(x, h2, axis: 3)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l8.(x)
+    x = @cvt2.(x)
     x = @bn8.(x)
-    x = ReLU.(x)
-
-    x = @l9.(x)
-    x = @bn9.(x)
-    x = ReLU.(x)
+    x = LeakyReLU.(x, 0.2)
     x = Concatenate.(x, h1, axis: 3)
 
-    x = @l10.(x)
-    x = ReLU.(x)
+    x = @cv7.(x)
+    x = LeakyReLU.(x, 0.2)
 
-    x = @l11.(x)
+    x = @cv8.(x)
     x = Tanh.(x)
     x
   end
@@ -147,6 +141,71 @@ class Discriminator < Model
   end
 end
 
+class Discriminator < Model
+  def initialize(gen_input_shape, gen_output_shape, base_num_filters)
+    super()
+    @gen_input_shape = gen_input_shape
+    @gen_output_shape = gen_output_shape
+    @cv1_1 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv1_2 = Conv2D.new(base_num_filters, 4, padding: true)
+    @cv2 = Conv2D.new(base_num_filters, 4, strides: 2, padding: true)
+    @cv3 = Conv2D.new(base_num_filters * 2, 4, padding: true)
+    @cv4 = Conv2D.new(base_num_filters * 2, 4, strides: 2, padding: true)
+    @d1 = Dense.new(1024)
+    @d2 = Dense.new(1)
+    @bn1_1 = BatchNormalization.new
+    @bn1_2 = BatchNormalization.new
+    @bn2 = BatchNormalization.new
+    @bn3 = BatchNormalization.new
+    @bn4 = BatchNormalization.new
+  end
+
+  def forward(inputs)
+    input, images = *inputs
+    x = InputLayer.new(@gen_input_shape).(input)
+    x = @cv1_1.(x)
+    x = @bn1_1.(x)
+    x1 = LeakyReLU.(x, 0.2)
+
+    x = InputLayer.new(@gen_output_shape).(images)
+    x = @cv1_2.(x)
+    x = @bn1_2.(x)
+    x2 = LeakyReLU.(x, 0.2)
+
+    x = Concatenate.(x1, x2)
+    x = @cv2.(x)
+    x = @bn2.(x)
+    x = LeakyReLU.(x, 0.2)
+
+    x = @cv3.(x)
+    x = @bn3.(x)
+    x = LeakyReLU.(x, 0.2)
+
+    x = @cv4.(x)
+    x = @bn4.(x)
+    x = LeakyReLU.(x, 0.2)
+
+    x = Flatten.(x)
+    x = @d1.(x)
+    x = LeakyReLU.(x, 0.2)
+
+    x = @d2.(x)
+    x
+  end
+
+  def enable_training
+    trainable_layers.each do |layer|
+      layer.trainable = true
+    end
+  end
+
+  def disable_training
+    trainable_layers.each do |layer|
+      layer.trainable = false
+    end
+  end
+end
+
 class DCGAN < Model
   attr_reader :gen
   attr_reader :dis

data/examples/pix2pix/train.rb

@@ -23,8 +23,8 @@ epochs = 20
 batch_size = 128
 
 if initial_epoch == 1
-  gen = Generator.new([32, 32, 1])
-  dis = Discriminator.new([32, 32, 1], [32, 32, 3])
+  gen = Generator.new([32, 32, 1], 32)
+  dis = Discriminator.new([32, 32, 1], [32, 32, 3], 32)
   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)

data/examples/vae.rb

@@ -28,24 +28,24 @@ end
 class Encoder < Model
   def initialize
     super
-    @l1 = Dense.new(196)
-    @l2 = Dense.new(49)
-    @l3_1 = Dense.new($z_dim)
-    @l3_2 = Dense.new($z_dim)
+    @d1 = Dense.new(196)
+    @d2 = Dense.new(49)
+    @d3_1 = Dense.new($z_dim)
+    @d3_2 = Dense.new($z_dim)
     @bn1 = BatchNormalization.new
     @bn2 = BatchNormalization.new
   end
 
   def forward(x)
     x = InputLayer.new(784).(x)
-    x = @l1.(x)
+    x = @d1.(x)
     x = @bn1.(x)
     x = ReLU.(x)
-    x = @l2.(x)
+    x = @d2.(x)
     x = @bn2.(x)
     x = ReLU.(x)
-    z_mean = @l3_1.(x)
-    z_sigma = @l3_2.(x)
+    z_mean = @d3_1.(x)
+    z_sigma = @d3_2.(x)
     [z_mean, z_sigma]
   end
 end
@@ -53,16 +53,16 @@ end
 class Decoder < Model
   def initialize
     super
-    @l3 = Dense.new(196)
-    @l4 = Dense.new(784)
+    @d1 = Dense.new(196)
+    @d2 = Dense.new(784)
     @bn1 = BatchNormalization.new
   end
 
   def forward(z)
-    x = @l3.(z)
+    x = @d1.(z)
     x = @bn1.(x)
     x = ReLU.(x)
-    x = @l4.(x)
+    x = @d2.(x)
     x
   end
 end

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

@@ -205,8 +205,11 @@ module DNN
 
       def forward_node(x)
         @x_shape = x.shape
-        @dim = x.shape[@axis]
-        x.sum(axis: @axis, keepdims: true)
+        if @axis
+          x.sum(axis: @axis, keepdims: true)
+        else
+          x.sum
+        end
       end
 
       def backward_node(dy)
@@ -236,8 +239,13 @@ module DNN
 
       def forward_node(x)
         @x_shape = x.shape
-        @dim = x.shape[@axis]
-        x.mean(axis: @axis, keepdims: true)
+        if @axis
+          @dim = x.shape[@axis]
+          x.mean(axis: @axis, keepdims: true)
+        else
+          @dim = x.size
+          x.mean
+        end
       end
 
       def backward_node(dy)

data/lib/dnn/core/models.rb

@@ -441,8 +441,9 @@ module DNN
         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)
+          lf = lfs[i]
+          if use_loss_activation && lf && lf.class.respond_to?(:activation)
+            y = lf.class.activation(y)
           end
           ys << y
         end
@@ -458,7 +459,12 @@ module DNN
                 else
                   x.reshape(1, *x.shape)
                 end
-        predict(input, use_loss_activation: use_loss_activation)[0, false]
+        y = predict(input, use_loss_activation: use_loss_activation)
+        if y.is_a?(Array)
+          y.map { |v| v[0, false] }
+        else
+          y[0, false]
+        end
       end
 
       # Add callback function.
@@ -526,7 +532,7 @@ module DNN
           @loss_func.each do |lf|
             lf.clean
           end
-        else
+        elsif @loss_func.is_a?(Losses::Loss)
           @loss_func.clean
         end
         @layers_cache = nil

data/lib/dnn/version.rb

@@ -1,3 +1,3 @@
 module DNN
-  VERSION = "1.1.4"
+  VERSION = "1.1.5"
 end

metadata

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