ruby-dnn 0.13.1 → 0.13.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58ef35a4277a86304c39350b743d308145da921fdc2db4308fa6ed208be47d93
-  data.tar.gz: b8238e52c849e222277284c20723c1a1ab72e70fed409ad1f2962a9ba93190b8
+  metadata.gz: d6410781490b2e9ce5ca1370bcca4905d4476bce2d49db64dda5f6b4a933f89f
+  data.tar.gz: e7ab72ce5b64a85c116ecbf81798aa6abd6f3356ca1a5e8512b2f0e6090b01c7
 SHA512:
-  metadata.gz: fd335af25c5d11745960364dc6096f18fbf78387358f5a1b24959328b001e87c3454132960133a74ba9cb81ac90f98e8d2663a9a9492b78d7a8558124471dc44
-  data.tar.gz: 132da9ac8fccee2c0de894543e2800b8066b75e746e4faed609594096e6d894a3938e69c0e1155056aef384dc522d39c647b9dfce8b9a5ceb659716f6ba961f0
+  metadata.gz: a08c6f35faccf3b18e61f04535fbf67ac6c961f57a52a75c82be573269cb1d0dd5e8d2d9d215a3c311919c84ceb82c94c0c78db04de2b872fa98078e475596e7
+  data.tar.gz: 221da0acff79523f23e881d5a53d511348162840bd79d27221d2ec65e0c1c508efc2090b79646711856c20cd4e407aa8a8d08a51650587083a2af1284cc92abf

data/lib/dnn/core/activations.rb

@@ -74,10 +74,6 @@ module DNN
     class LeakyReLU < Layers::Layer
       attr_reader :alpha
 
-      def self.from_hash(hash)
-        self.new(hash[:alpha])
-      end
-
       # @param [Float] alpha The slope when the output value is negative.
       def initialize(alpha = 0.3)
         super()
@@ -100,16 +96,16 @@ module DNN
       def to_hash
         super(alpha: @alpha)
       end
+
+      def load_hash(hash)
+        initialize(hash[:alpha])
+      end
     end
 
 
     class ELU < Layers::Layer
       attr_reader :alpha
 
-      def self.from_hash(hash)
-        self.new(hash[:alpha])
-      end
-
       # @param [Float] alpha The slope when the output value is negative.
       def initialize(alpha = 1.0)
         super()
@@ -139,6 +135,10 @@ module DNN
       def to_hash
         super(alpha: @alpha)
       end
+
+      def load_hash(hash)
+        initialize(hash[:alpha])
+      end
     end
 
   end

data/lib/dnn/core/cnn_layers.rb

@@ -92,17 +92,6 @@ module DNN
       attr_reader :strides
       attr_reader :padding
 
-      def self.from_hash(hash)
-        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].
@@ -184,6 +173,17 @@ module DNN
               strides: @strides,
               padding: @padding)
       end
+
+      def load_hash(hash)
+        initialize(hash[:num_filters], hash[:filter_size],
+                   weight_initializer: Initializers::Initializer.from_hash(hash[:weight_initializer]),
+                   bias_initializer: Initializers::Initializer.from_hash(hash[:bias_initializer]),
+                   weight_regularizer: Regularizers::Regularizer.from_hash(hash[:weight_regularizer]),
+                   bias_regularizer: Regularizers::Regularizer.from_hash(hash[:bias_regularizer]),
+                   use_bias: hash[:use_bias],
+                   strides: hash[:strides],
+                   padding: hash[:padding])
+      end
     end
 
 
@@ -195,17 +195,6 @@ module DNN
       attr_reader :strides
       attr_reader :padding
 
-      def self.from_hash(hash)
-        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].
@@ -289,6 +278,17 @@ module DNN
               strides: @strides,
               padding: @padding)
       end
+
+      def load_hash(hash)
+        initialize(hash[:num_filters], hash[:filter_size],
+                   weight_initializer: Initializers::Initializer.from_hash(hash[:weight_initializer]),
+                   bias_initializer: Initializers::Initializer.from_hash(hash[:bias_initializer]),
+                   weight_regularizer: Regularizers::Regularizer.from_hash(hash[:weight_regularizer]),
+                   bias_regularizer: Regularizers::Regularizer.from_hash(hash[:bias_regularizer]),
+                   use_bias: hash[:use_bias],
+                   strides: hash[:strides],
+                   padding: hash[:padding])
+      end
     end
 
 
@@ -300,10 +300,6 @@ module DNN
       attr_reader :strides
       attr_reader :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.
@@ -345,6 +341,11 @@ module DNN
               strides: @strides,
               padding: @padding)
       end
+
+      def load_hash(hash)
+        initialize(hash[:pool_size], strides: hash[:strides], padding: hash[:padding])
+      end
+
     end
 
 
@@ -396,10 +397,6 @@ module DNN
 
       attr_reader :unpool_size
 
-      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()
@@ -445,6 +442,10 @@ module DNN
       def to_hash
         super(unpool_size: @unpool_size)
       end
+
+      def load_hash(hash)
+        initialize(hash[:unpool_size])
+      end
     end
 
   end

data/lib/dnn/core/embedding.rb

@@ -7,12 +7,6 @@ module DNN
       attr_reader :weight_initializer
       attr_reader :weight_regularizer
 
-      def self.from_hash(hash)
-        self.new(hash[:input_shape], hash[:input_length],
-                 weight_initializer: DNN::Utils.hash_to_obj(hash[:weight_initializer]),
-                 weight_regularizer: DNN::Utils.hash_to_obj(hash[:weight_regularizer]))
-      end
-
       # @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.
       # @param [DNN::Initializers::Initializer] weight_initializer Weight initializer.
@@ -67,6 +61,12 @@ module DNN
               weight_initializer: @weight_initializer.to_hash, weight_regularizer: @weight_regularizer&.to_hash)
       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]))
+      end
+
       def get_params
         { weight: @weight }
       end

data/lib/dnn/core/initializers.rb

@@ -2,6 +2,15 @@ module DNN
   module Initializers
 
     class Initializer
+      def self.from_hash(hash)
+        return nil unless hash
+        initializer_class = DNN.const_get(hash[:class])
+        initializer = initializer_class.allocate
+        raise DNN_Error.new("#{initializer.class} is not an instance of #{self} class.") unless initializer.is_a?(self)
+        initializer.load_hash(hash)
+        initializer
+      end
+
       # @param [Boolean | Integer] seed Seed of random number used for initialize parameter.
       #                                 Set true to determine seed as random.
       def initialize(seed: false)
@@ -20,6 +29,10 @@ module DNN
         hash.merge!(merge_hash) if merge_hash
         hash
       end
+
+      def load_hash(hash)
+        initialize
+      end
     end
 
 
@@ -33,10 +46,6 @@ module DNN
     class Const < Initializer
       attr_reader :const
 
-      def self.from_hash(hash)
-        self.new(hash[:const])
-      end
-
       # @param [Float] const Constant value of initialization.
       def initialize(const)
         super()
@@ -50,6 +59,10 @@ module DNN
       def to_hash
         super(const: @const)
       end
+
+      def load_hash(hash)
+        initialize(hash[:const])
+      end
     end
 
 
@@ -57,10 +70,6 @@ module DNN
       attr_reader :mean
       attr_reader :std
 
-      def self.from_hash(hash)
-        self.new(hash[:mean], hash[:std], seed: hash[:seed])
-      end
-
       # @param [Float] mean Average of initialization value.
       # @param [Float] std Variance of initialization value.
       def initialize(mean = 0, std = 0.05, seed: true)
@@ -77,6 +86,10 @@ module DNN
       def to_hash
         super(mean: @mean, std: @std)
       end
+
+      def load_hash(hash)
+        initialize(hash[:mean], hash[:std], seed: hash[:seed])
+      end
     end
 
 
@@ -84,10 +97,6 @@ module DNN
       attr_reader :min
       attr_reader :max
 
-      def self.from_hash(hash)
-        self.new(hash[:min], hash[:max], seed: hash[:seed])
-      end
-
       # @param [Float] min Min of initialization value.
       # @param [Float] max Max of initialization value.
       def initialize(min = -0.05, max = 0.05, seed: true)
@@ -104,6 +113,10 @@ module DNN
       def to_hash
         super(min: @min, max: @max)
       end
+
+      def load_hash(hash)
+        initialize(hash[:min], hash[:max], seed: hash[:seed])
+      end
     end
 
 

data/lib/dnn/core/layers.rb

@@ -10,8 +10,18 @@ module DNN
         self.new(*args).(x)
       end
 
+      def self.from_hash(hash)
+        return nil unless hash
+        layer_class = DNN.const_get(hash[:class])
+        layer = layer_class.allocate
+        raise DNN_Error.new("#{layer.class} is not an instance of #{self} class.") unless layer.is_a?(self)
+        layer.load_hash(hash)
+        layer
+      end
+
       def initialize
         @built = false
+        @name = nil
       end
 
       # Forward propagation and create a link.
@@ -57,10 +67,14 @@ module DNN
 
       # Layer to a hash.
       def to_hash(merge_hash = nil)
-        hash = { class: self.class.name }
+        hash = { class: self.class.name, name: @name }
         hash.merge!(merge_hash) if merge_hash
         hash
       end
+
+      def load_hash(hash)
+        initialize
+      end
     end
 
 
@@ -87,10 +101,6 @@ module DNN
         self.new(shape[1..-1]).(input)
       end
 
-      def self.from_hash(hash)
-        self.new(hash[:input_shape])
-      end
-
       # @param [Array] input_dim_or_shape Setting the shape or dimension of the input data.
       def initialize(input_dim_or_shape)
         super()
@@ -127,6 +137,10 @@ module DNN
       def to_hash
         super(input_shape: @input_shape)
       end
+
+      def load_hash(hash)
+        initialize(hash[:input_shape])
+      end
     end
 
 
@@ -196,15 +210,6 @@ module DNN
     class Dense < Connection
       attr_reader :num_nodes
 
-      def self.from_hash(hash)
-        self.new(hash[:num_nodes],
-                 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])
-      end
-
       # @param [Integer] num_nodes Number of nodes.
       def initialize(num_nodes,
                      weight_initializer: Initializers::RandomNormal.new,
@@ -250,6 +255,15 @@ module DNN
       def to_hash
         super(num_nodes: @num_nodes)
       end
+
+      def load_hash(hash)
+        initialize(hash[:num_nodes],
+                   weight_initializer: Initializers::Initializer.from_hash(hash[:weight_initializer]),
+                   bias_initializer: Initializers::Initializer.from_hash(hash[:bias_initializer]),
+                   weight_regularizer: Regularizers::Regularizer.from_hash(hash[:weight_regularizer]),
+                   bias_regularizer: Regularizers::Regularizer.from_hash(hash[:bias_regularizer]),
+                   use_bias: hash[:use_bias])
+      end
     end
 
 
@@ -269,10 +283,6 @@ module DNN
 
 
     class Reshape < Layer
-      def self.from_hash(hash)
-        self.new(hash[:output_shape])
-      end
-
       def initialize(output_shape)
         super()
         @output_shape = output_shape
@@ -293,6 +303,10 @@ module DNN
       def to_hash
         super(output_shape: @output_shape)
       end
+
+      def load_hash(hash)
+        initialize(hash[:output_shape])
+      end
     end
 
 
@@ -300,10 +314,6 @@ module DNN
       attr_accessor :dropout_ratio
       attr_reader :use_scale
 
-      def self.from_hash(hash)
-        self.new(hash[:dropout_ratio], seed: hash[:seed], use_scale: hash[:use_scale])
-      end
-
       # @param [Float] dropout_ratio Nodes dropout ratio.
       # @param [Integer] seed Seed of random number used for masking.
       # @param [Boolean] use_scale Set to true to scale the output according to the dropout ratio.
@@ -335,6 +345,10 @@ module DNN
       def to_hash
         super(dropout_ratio: @dropout_ratio, seed: @seed, use_scale: @use_scale)
       end
+
+      def load_hash(hash)
+        initialize(hash[:dropout_ratio], seed: hash[:seed], use_scale: hash[:use_scale])
+      end
     end
 
   end

data/lib/dnn/core/losses.rb

@@ -2,6 +2,15 @@ module DNN
   module Losses
 
     class Loss
+      def self.from_hash(hash)
+        return nil unless hash
+        loss_class = DNN.const_get(hash[:class])
+        loss = loss_class.allocate
+        raise DNN_Error.new("#{loss.class} is not an instance of #{self} class.") unless loss.is_a?(self)
+        loss.load_hash(hash)
+        loss
+      end
+
       def loss(y, t, layers = nil)
         unless y.shape == t.shape
           raise DNN_ShapeError.new("The shape of y does not match the t shape. y shape is #{y.shape}, but t shape is #{t.shape}.")
@@ -40,6 +49,10 @@ module DNN
         hash.merge!(merge_hash) if merge_hash
         hash
       end
+
+      def load_hash(hash)
+        initialize
+      end
     end
 
     class MeanSquaredError < Loss
@@ -115,10 +128,6 @@ module DNN
     class SoftmaxCrossEntropy < Loss
       attr_accessor :eps
 
-      def self.from_hash(hash)
-        self.new(eps: hash[:eps])
-      end
-
       def self.softmax(y)
         Xumo::NMath.exp(y) / Xumo::NMath.exp(y).sum(1, keepdims: true)
       end
@@ -141,16 +150,16 @@ module DNN
       def to_hash
         super(eps: @eps)
       end
+
+      def load_hash(hash)
+        initialize(eps: hash[:eps])
+      end
     end
 
 
     class SigmoidCrossEntropy < Loss
       attr_accessor :eps
 
-      def self.from_hash(hash)
-        self.new(eps: hash[:eps])
-      end
-
       # @param [Float] eps Value to avoid nan.
       def initialize(eps: 1e-7)
         @eps = eps
@@ -168,6 +177,10 @@ module DNN
       def to_hash
         super(eps: @eps)
       end
+
+      def load_hash(hash)
+        initialize(eps: hash[:eps])
+      end
     end
 
   end

data/lib/dnn/core/merge_layers.rb

@@ -43,10 +43,6 @@ module DNN
     class Concatenate < MergeLayer
       attr_reader :axis
 
-      def self.from_hash(hash)
-        self.new(axis: hash[:axis])
-      end
-
       def initialize(axis: 1)
         super()
         @axis = axis
@@ -65,6 +61,10 @@ module DNN
       def to_hash
         super(axis: @axis)
       end
+
+      def load_hash(hash)
+        initialize(axis: hash[:axis])
+      end
     end
 
   end

data/lib/dnn/core/normalizations.rb

@@ -10,10 +10,6 @@ module DNN
       attr_accessor :momentum
       attr_accessor :eps
 
-      def self.from_hash(hash)
-        self.new(axis: hash[:axis], momentum: hash[:momentum])
-      end
-
       # @param [Integer] axis The axis to normalization.
       # @param [Float] momentum Exponential moving average of mean and variance.
       # @param [Float] eps Value to avoid division by zero.
@@ -68,6 +64,10 @@ module DNN
         super(axis: @axis, momentum: @momentum, eps: @eps)
       end
 
+      def load_hash(hash)
+        initialize(axis: hash[:axis], momentum: hash[:momentum])
+      end
+
       def get_params
         { gamma: @gamma, beta: @beta, running_mean: @running_mean, running_var: @running_var }
       end

data/lib/dnn/core/optimizers.rb

@@ -6,8 +6,17 @@ module DNN
       attr_reader :status
       attr_accessor :clip_norm
 
+      def self.from_hash(hash)
+        return nil unless hash
+        optimizer_class = DNN.const_get(hash[:class])
+        optimizer = optimizer_class.allocate
+        raise DNN_Error.new("#{optimizer.class} is not an instance of #{self} class.") unless optimizer.is_a?(self)
+        optimizer.load_hash(hash)
+        optimizer
+      end
+
       def self.load(dumped)
-        opt = Utils.hash_to_obj(dumped[:hash])
+        opt = from_hash(dumped[:hash])
         dumped[:status].each do |key, state|
           state = state.clone
           opt.status[key] = state
@@ -56,6 +65,10 @@ module DNN
           param.grad *= rate
         end
       end
+
+      def load_hash(hash)
+        initialize(clip_norm: hash[:clip_norm])
+      end
     end
 
 
@@ -63,10 +76,6 @@ module DNN
       attr_accessor :lr
       attr_accessor :momentum
 
-      def self.from_hash(hash)
-        self.new(hash[:lr], momentum: hash[:momentum], clip_norm: hash[:clip_norm])
-      end
-
       # @param [Float] lr Learning rate.
       # @param [Float] momentum Momentum coefficient.
       def initialize(lr = 0.01, momentum: 0, clip_norm: nil)
@@ -92,6 +101,10 @@ module DNN
           param.data -= amount
         end
       end
+
+      def load_hash(hash)
+        initialize(hash[:lr], momentum: hash[:momentum], clip_norm: hash[:clip_norm])
+      end
     end
 
 
@@ -115,10 +128,6 @@ module DNN
       attr_accessor :lr
       attr_accessor :eps
 
-      def self.from_hash(hash)
-        self.new(hash[:lr], eps: hash[:eps], clip_norm: hash[:clip_norm])
-      end
-
       # @param [Float] lr Learning rate.
       # @param [Float] eps Value to avoid division by zero.
       def initialize(lr = 0.01, eps: 1e-7, clip_norm: nil)
@@ -140,6 +149,10 @@ module DNN
       def to_hash
         super(lr: @lr, eps: @eps)
       end
+
+      def load_hash(hash)
+        initialize(hash[:lr], eps: hash[:eps], clip_norm: hash[:clip_norm])
+      end
     end
 
 
@@ -148,10 +161,6 @@ module DNN
       attr_accessor :alpha
       attr_accessor :eps
 
-      def self.from_hash(hash)
-        self.new(hash[:lr], alpha: hash[:alpha], eps: hash[:eps], clip_norm: hash[:clip_norm])
-      end
-
       # @param [Float] lr Learning rate.
       # @param [Float] alpha Moving average index of past slopes.
       # @param [Float] eps Value to avoid division by zero.
@@ -175,6 +184,10 @@ module DNN
           param.data -= (@lr / Xumo::NMath.sqrt(@g[param.name] + @eps)) * param.grad
         end
       end
+
+      def load_hash(hash)
+        initialize(hash[:lr], alpha: hash[:alpha], eps: hash[:eps], clip_norm: hash[:clip_norm])
+      end
     end
 
 
@@ -182,10 +195,6 @@ module DNN
       attr_accessor :rho
       attr_accessor :eps
 
-      def self.from_hash(hash)
-        self.new(rho: hash[:rho], eps: hash[:eps], clip_norm: hash[:clip_norm])
-      end
-
       # @param [Float] rho Moving average index of past slopes.
       # @param [Float] eps Value to avoid division by zero.
       def initialize(rho: 0.95, eps: 1e-6, clip_norm: nil)
@@ -211,6 +220,10 @@ module DNN
           param.data -= v
         end
       end
+
+      def load_hash(hash)
+        initialize(rho: hash[:rho], eps: hash[:eps], clip_norm: hash[:clip_norm])
+      end
     end
 
 
@@ -219,10 +232,6 @@ module DNN
       attr_accessor :alpha
       attr_accessor :eps
 
-      def self.from_hash(hash)
-        self.new(hash[:lr], alpha: hash[:alpha], eps: hash[:eps], clip_norm: hash[:clip_norm])
-      end
-
       # @param [Float] lr Learning rate.
       # @param [Float] alpha Moving average index of past slopes.
       # @param [Float] eps Value to avoid division by zero.
@@ -249,6 +258,10 @@ module DNN
           param.data -= (@lr / Xumo::NMath.sqrt(@v[param.name] - @m[param.name] ** 2 + @eps)) * param.grad
         end
       end
+
+      def load_hash(hash)
+        initialize(hash[:lr], alpha: hash[:alpha], eps: hash[:eps], clip_norm: hash[:clip_norm])
+      end
     end
 
 
@@ -259,11 +272,6 @@ module DNN
       attr_accessor :eps
       attr_reader :amsgrad
 
-      def self.from_hash(hash)
-        self.new(alpha: hash[:alpha], beta1: hash[:beta1], beta2: hash[:beta2],
-                 eps: hash[:eps], amsgrad: hash[:amsgrad], clip_norm: hash[:clip_norm])
-      end
-
       # @param [Float] alpha Value used to calculate learning rate.
       # @param [Float] beta1 Moving average index of beta1.
       # @param [Float] beta2 Moving average index of beta2.
@@ -307,6 +315,11 @@ module DNN
           end
         end
       end
+
+      def load_hash(hash)
+        initialize(alpha: hash[:alpha], beta1: hash[:beta1], beta2: hash[:beta2],
+                   eps: hash[:eps], amsgrad: hash[:amsgrad], clip_norm: hash[:clip_norm])
+      end
     end
 
 
@@ -314,11 +327,6 @@ module DNN
       attr_accessor :final_lr
       attr_accessor :gamma
 
-      def self.from_hash(hash)
-        self.new(alpha: hash[:alpha], beta1: hash[:beta1], beta2: hash[:beta2],
-                 final_lr: hash[:final_lr], gamma: hash[:gamma], eps: hash[:eps], amsgrad: hash[:amsgrad], clip_norm: hash[:clip_norm])
-      end
-
       # @param [Float] final_lr Final learning rate.
       # @param [Float] gamma Lower and upper range value.
       def initialize(alpha: 0.001, beta1: 0.9, beta2: 0.999, final_lr: 0.1, gamma: 0.001, eps: 1e-7, amsgrad: false, clip_norm: nil)
@@ -360,6 +368,11 @@ module DNN
         lr[lr > upper_bound] = upper_bound
         lr
       end
+
+      def load_hash(hash)
+        initialize(alpha: hash[:alpha], beta1: hash[:beta1], beta2: hash[:beta2],
+                   final_lr: hash[:final_lr], gamma: hash[:gamma], eps: hash[:eps], amsgrad: hash[:amsgrad], clip_norm: hash[:clip_norm])
+      end
     end
 
   end

data/lib/dnn/core/regularizers.rb

@@ -4,6 +4,15 @@ module DNN
     class Regularizer
       attr_accessor :param
 
+      def self.from_hash(hash)
+        return nil unless hash
+        regularizer_class = DNN.const_get(hash[:class])
+        regularizer = regularizer_class.allocate
+        raise DNN_Error.new("#{regularizer.class} is not an instance of #{self} class.") unless regularizer.is_a?(self)
+        regularizer.load_hash(hash)
+        regularizer
+      end
+
       def forward(x)
         raise NotImplementedError.new("Class '#{self.class.name}' has implement method 'forward'")
       end
@@ -17,15 +26,15 @@ module DNN
         hash.merge!(merge_hash)
         hash
       end
+
+      def load_hash(hash)
+        raise NotImplementedError.new("Class '#{self.class.name}' has implement method 'load_hash'")
+      end
     end
 
     class L1 < Regularizer
       attr_accessor :l1_lambda
 
-      def self.from_hash(hash)
-        self.new(hash[:l1_lambda])
-      end
-
       # @param [Float] l1_lambda L1 regularizer coefficient.
       def initialize(l1_lambda = 0.01)
         @l1_lambda = l1_lambda
@@ -44,16 +53,16 @@ module DNN
       def to_hash
         super(l1_lambda: @l1_lambda)
       end
+
+      def load_hash(hash)
+        initialize(hash[:l1_lambda])
+      end
     end
 
 
     class L2 < Regularizer
       attr_accessor :l2_lambda
 
-      def self.from_hash(hash)
-        self.new(hash[:l2_lambda])
-      end
-
       # @param [Float] l2_lambda L2 regularizer coefficient.
       def initialize(l2_lambda = 0.01)
         @l2_lambda = l2_lambda
@@ -70,16 +79,16 @@ module DNN
       def to_hash
         super(l2_lambda: @l2_lambda)
       end
+
+      def load_hash(hash)
+        initialize(hash[:l2_lambda])
+      end
     end
 
     class L1L2 < Regularizer
       attr_accessor :l1_lambda
       attr_accessor :l2_lambda
 
-      def self.from_hash(hash)
-        self.new(hash[:l1_lambda], hash[:l2_lambda])
-      end
-
       # @param [Float] l1_lambda L1 regularizer coefficient.
       # @param [Float] l2_lambda L2 regularizer coefficient.
       def initialize(l1_lambda = 0.01, l2_lambda = 0.01)
@@ -103,6 +112,10 @@ module DNN
       def to_hash
         super(l1_lambda: l1_lambda, l2_lambda: l2_lambda)
       end
+
+      def load_hash(hash)
+        initialize(hash[:l1_lambda], hash[:l2_lambda])
+      end
     end
 
   end

data/lib/dnn/core/rnn_layers.rb

@@ -11,19 +11,6 @@ module DNN
       attr_reader :recurrent_weight_initializer
       attr_reader :recurrent_weight_regularizer
 
-      def self.from_hash(hash)
-        self.new(hash[:num_nodes],
-                 stateful: hash[:stateful],
-                 return_sequences: hash[:return_sequences],
-                 weight_initializer: Utils.hash_to_obj(hash[:weight_initializer]),
-                 recurrent_weight_initializer: Utils.hash_to_obj(hash[:recurrent_weight_initializer]),
-                 bias_initializer: Utils.hash_to_obj(hash[:bias_initializer]),
-                 weight_regularizer: Utils.hash_to_obj(hash[:weight_regularizer]),
-                 recurrent_weight_regularizer: Utils.hash_to_obj(hash[:recurrent_weight_regularizer]),
-                 bias_regularizer: Utils.hash_to_obj(hash[:bias_regularizer]),
-                 use_bias: hash[:use_bias])
-      end
-
       # @param [Integer] num_nodes Number of nodes.
       # @param [Boolean] stateful Maintain state between batches.
       # @param [Boolean] return_sequences Set the false, only the last of each cell of RNN is left.
@@ -105,6 +92,19 @@ module DNN
         super(hash)
       end
 
+      def load_hash(hash)
+        initialize(hash[:num_nodes],
+                   stateful: hash[:stateful],
+                   return_sequences: hash[:return_sequences],
+                   weight_initializer: Initializers::Initializer.from_hash(hash[:weight_initializer]),
+                   recurrent_weight_initializer: Initializers::Initializer.from_hash(hash[:recurrent_weight_initializer]),
+                   bias_initializer: Initializers::Initializer.from_hash(hash[:bias_initializer]),
+                   weight_regularizer: Regularizers::Regularizer.from_hash(hash[:weight_regularizer]),
+                   recurrent_weight_regularizer: Regularizers::Regularizer.from_hash(hash[:recurrent_weight_regularizer]),
+                   bias_regularizer: Regularizers::Regularizer.from_hash(hash[:bias_regularizer]),
+                   use_bias: hash[:use_bias])
+      end
+
       def get_params
         { weight: @weight, recurrent_weight: @recurrent_weight, bias: @bias, hidden: @hidden }
       end
@@ -166,20 +166,6 @@ module DNN
     class SimpleRNN < RNN
       attr_reader :activation
 
-      def self.from_hash(hash)
-        self.new(hash[:num_nodes],
-                 stateful: hash[:stateful],
-                 return_sequences: hash[:return_sequences],
-                 activation: Utils.hash_to_obj(hash[:activation]),
-                 weight_initializer: Utils.hash_to_obj(hash[:weight_initializer]),
-                 recurrent_weight_initializer: Utils.hash_to_obj(hash[:recurrent_weight_initializer]),
-                 bias_initializer: Utils.hash_to_obj(hash[:bias_initializer]),
-                 weight_regularizer: Utils.hash_to_obj(hash[:weight_regularizer]),
-                 recurrent_weight_regularizer: Utils.hash_to_obj(hash[:recurrent_weight_regularizer]),
-                 bias_regularizer: Utils.hash_to_obj(hash[:bias_regularizer]),
-                 use_bias: hash[:use_bias])
-      end
-
       # @param [DNN::Layers::Layer] activation Activation function to use in a recurrent network.
       def initialize(num_nodes,
                      stateful: false,
@@ -220,6 +206,20 @@ module DNN
       def to_hash
         super(activation: @activation.to_hash)
       end
+
+      def load_hash(hash)
+        initialize(hash[:num_nodes],
+                   stateful: hash[:stateful],
+                   return_sequences: hash[:return_sequences],
+                   activation: Layers::Layer.from_hash(hash[:activation]),
+                   weight_initializer: Initializers::Initializer.from_hash(hash[:weight_initializer]),
+                   recurrent_weight_initializer: Initializers::Initializer.from_hash(hash[:recurrent_weight_initializer]),
+                   bias_initializer: Initializers::Initializer.from_hash(hash[:bias_initializer]),
+                   weight_regularizer: Regularizers::Regularizer.from_hash(hash[:weight_regularizer]),
+                   recurrent_weight_regularizer: Regularizers::Regularizer.from_hash(hash[:recurrent_weight_regularizer]),
+                   bias_regularizer: Regularizers::Regularizer.from_hash(hash[:bias_regularizer]),
+                   use_bias: hash[:use_bias])
+      end
     end
 
 

data/lib/dnn/core/savers.rb

@@ -35,7 +35,7 @@ module DNN
       private def load_bin(bin)
         data = Marshal.load(Zlib::Inflate.inflate(bin))
         opt = Optimizers::Optimizer.load(data[:optimizer])
-        loss_func = Utils.hash_to_obj(data[:loss_func])
+        loss_func = Losses::Loss.from_hash(data[:loss_func])
         @model.setup(opt, loss_func)
         @model.predict1(Xumo::SFloat.zeros(*data[:input_shape]))
         set_all_params_data(data[:params])
@@ -47,8 +47,8 @@ module DNN
 
       def load_bin(bin)
         data = JSON.parse(bin, symbolize_names: true)
-        opt = Utils.hash_to_obj(data[:optimizer])
-        loss_func = Utils.hash_to_obj(data[:loss_func])
+        opt = Optimizers::Optimizer.from_hash(data[:optimizer])
+        loss_func = Losses::Loss.from_hash(data[:loss_func])
         @model.setup(opt, loss_func)
         @model.predict1(Xumo::SFloat.zeros(*data[:input_shape]))
         base64_to_params_data(data[:params])

data/lib/dnn/core/utils.rb

@@ -18,10 +18,7 @@ module DNN
     def self.hash_to_obj(hash)
       return nil if hash == nil
       dnn_class = DNN.const_get(hash[:class])
-      if dnn_class.respond_to?(:from_hash)
-        return dnn_class.from_hash(hash)
-      end
-      dnn_class.new
+      dnn_class.from_hash(hash)
     end
 
     # Return the result of the sigmoid function.

data/lib/dnn/version.rb

@@ -1,3 +1,3 @@
 module DNN
-  VERSION = "0.13.1"
+  VERSION = "0.13.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dnn
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.13.2
 platform: ruby
 authors:
 - unagiootoro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-21 00:00:00.000000000 Z
+date: 2019-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray