ruby-dnn 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d462153bdd72ecf6df60f2d6bc6922ee76f3fd1318f03d33e644c91fe0b1881e
-  data.tar.gz: 3ba2d911fbb994f18aa1bf9bb389e1c50fd31c10c5e1dcded5c9f4567b7e35ef
+  metadata.gz: 634ecbbfbad30f1660a3f04adc9e3a3835d54b93dc84eb765962406111243f46
+  data.tar.gz: 7b00ad63ddf17e95df2e852b29005fdb35671b2bed12e951d8c54fcc3415abe7
 SHA512:
-  metadata.gz: f06a8bc128241b4e50c72ccc9e7a72944b705991d6f52b65a1276042f78bfd50d19cd8f971a717fdb3699b7bb93bc136fc44f24b4202f2aff9f98f295e20198f
-  data.tar.gz: 2e115414aab91238cc1ad46255c5ca407bbcb786a41d12626671d4e8cb9a93d34a455a23d41ab2bf90d52e9c5a4a10e51a6686a240cc5fd642028e5111167c8c
+  metadata.gz: fba18cc2365d798e27fc3fa8be1f296664d23ef2b04d0e6d8db635189b4cf591675e29c8314437b00e8dc122d143ec956486915ed84a37e8b19b0952687a6467
+  data.tar.gz: f2d7f67c6331db0d58a01b3dbbc3f9b136fc692900811e88251e0a6865a0b0790e4291621296155f3f7778051ac0323a727ae6d1e812baebf76096a25b9ee0d9

data/API-Reference.ja.md

@@ -1,8 +1,16 @@
-## ruby-dnnのAPIリファレンスです。
+# APIリファレンス
+ruby-dnnのAPIリファレンスです。このリファレンスでは、APIを利用するうえで必要となるクラスとメソッドしか記載していません。
+そのため、プログラムの詳細が必要な場合は、ソースコードを参照してください。
+
+対応バージョン:0.1.6
 
 # module DNN
 ruby-dnnの名前空間をなすモジュールです。
 
+## 【Constants】
+## VERSION
+ruby-dnnのバージョン。
+
 
 # class Model
  ニューラルネットワークのモデルを作成するクラスです。
@@ -15,23 +23,56 @@ marshalファイルを読み込み、モデルを作成します。
 * String file_name  
   読み込むmarshalファイル名。
 ### return
-なし。
+Model  
+生成したモデル。
+
+## def self.load_json(json_str)
+json文字列からモデルを作成します。
+### arguments
+* String json_str
+  json文字列。
+### return
+Model  
+生成したモデル。
 
 ## 【Instance methods】
 
-## def initialize
-コンストラクタ。
+## def load_json_params(json_str)
+学習パラメータをjson文字列から取得し、モデルにセットします。
 ### arguments
+* String json_str
+学習パラメータを変換して生成したjson文字列。
+### return
 なし。
 
 ## def save(file_name)
 モデルをmarshalファイルに保存します。
+このmarshalファイルには、学習パラメータ及びOptimizerの状態が保存されるため、
+読み込んだ後、正確に学習を継続することができます。
 ### arguments
 * String file_name  
 書き込むファイル名。
 ### return
 なし。
 
+## def to_json
+モデルをjson文字列に変換します。
+変換したjson文字列には学習パラメータの情報は含まれません。
+学習パラメータの情報を取得したい場合は、params_to_jsonを使用してください。
+### arguments
+なし。
+### return
+String  
+モデルを変換して生成したjson文字列。
+
+## def params_to_json
+学習パラメータをjson文字列に変換します。
+### arguments
+なし。
+### return
+String  
+学習パラメータを変換して生成したjson文字列。
+
 ## def <<(layer)
 モデルにレイヤーを追加します。
 ### arguments
@@ -168,34 +209,19 @@ SFloat
 Array  
 レイヤーの形状。Layerクラスのshapeメソッドでは、前レイヤーの形状を返却します。
 
-## def prev_layer
-前のレイヤーを取得します。
+## abstruct def to_hash
+レイヤーをハッシュに変換します。このメソッドは、モデルをjsonに変換するために使用されます。このメソッドが返すハッシュの要素には、{name: self.class.name}が含まれていなければなりません。
 ### arguments
 なし。
 ### return
-Layer  
-前のレイヤー。
+Hash  
+レイヤーを変換したハッシュ。
 
 
 # class HasParamLayer < Layer
 学習可能なパラメータを持つ全てのレイヤーのスーパークラスです。
 
 ## 【Instance methods】
-## def initialize
-コンストラクタ
-### arguments
-なし。
-
-## override def init(model)
-Layerクラスからオーバーライドされたメソッドです。
-init_paramの呼び出しを行います。
-
-## def update
-オプティマイザーを用いてパラメータの更新を行います。
-### arguments
-なし。
-### return
-なし。
 
 ## private abstruct def init_params
 更新可能なパラメータを初期化します。HasParamLayerクラスを継承するクラスは、このメソッドを実装する必要があります。
@@ -208,11 +234,6 @@ init_paramの呼び出しを行います。
 # class InputLayer < Layer
 入力層に該当するレイヤーです。モデルの先頭レイヤーは、必ずこのクラスのインスタンスでなければなりません。
 
-## 【Properties】
-## attr_reaedr :shape  
-SFloat shape  
-コンストラクタで設定されたshapeを取得します。
-
 ## 【Instance methods】
 ## def initialize(dim_or_shape)
 コンストラクタ
@@ -220,12 +241,6 @@ SFloat shape
 * Integer|Array dim_or_shape  
 入力層のdimentionまたはshapeを指定します。引数がIntegerだとdimentionとみなし、Arrayだとshapeとみなします。
 
-## override def forward(x)
-入力値をそのまま順方向に伝搬します。
-
-## override def backward(dout)
-逆方向から伝搬してきた微分値をそのまま逆方向に伝搬します。
-
 
 # class Dense
 全結合レイヤーを扱うクラスです。
@@ -254,15 +269,6 @@ nilを指定すると、Zerosイニシャライザーが使用されます。
 * Float weight_decay: 0
 重み減衰の係数を設定します。
 
-## override def forward(x)
-ノードを順方向に伝搬します。
-
-## override def backward(dout)
-ノードを逆方向に伝搬します。
-
-## override def shape
-[ノード数]をshapeとして返却します。
-
 
 # class Conv2D < HasParamLayer
 畳み込みレイヤーを扱うクラスです。
@@ -289,18 +295,6 @@ nilを指定すると、RandomNormalイニシャライザーが使用されま
 * Float weight_decay: 0  
 重み減衰を行うL2正則化項の強さを設定します。
 
-## override def init(model)
-モデルのコンパイル時に、レイヤーを初期化するために使用されます。
-
-## override def forward(x)
-イメージにフィルターを適用して順方向に伝搬します。
-
-## override def backward(dout)
-フィルターが適用されたイメージを変換して、逆方向に伝搬します。
-
-## override def shape
-畳み込み後のイメージの次元を返します。
-
 
 # class MaxPool2D < Layer
 maxプーリングを行うレイヤーです。
@@ -318,32 +312,10 @@ maxプーリングを行うレイヤーです。
 * Integer padding: 0
 イメージに対してゼロパディングを行う単位を指定します。
 
-## override def init(model)
-モデルのコンパイル時に、レイヤーを初期化するために使用されます。
-
-## override def forward(x)
-イメージにプーリングを行い、順方向に伝搬します。
-
-## override def backward(dout)
-プーリングされたイメージを変換し、逆方向に伝搬します。
-
-## override def shape
-プーリング後のイメージのshapeを返します。
-
 
 # class Flatten
 N次元のデータを平坦化します。
 
-## 【Instance methods】
-## override def forward(x)
-データを平坦化して、順方向に伝搬します。
-
-## override def backward(dout)
-データを元の形状に戻し、逆方向に伝搬します。
-
-## override def shape
-前レイヤーの形状を平坦化して返します。
-
 
 # class Reshape < Layer
 データの形状を変更します。
@@ -355,11 +327,6 @@ N次元のデータを平坦化します。
 * Array<Integer> shape  
 データの形状を変更するshapeです。
 
-## override def forward(x)
-データをコンストラクタで指定したshapeにreshapeして、順方向に伝搬します。
-
-## override def backward(dout)
-データを元のshapeにreshapeして、逆方向に伝搬します。
 
 # class OutputLayer < Layer
 出力層に該当するレイヤーです。出力層の活性化関数は、全てこのクラスを継承する必要があります。
@@ -380,14 +347,6 @@ SFloat y
 ### return
 損失関数の値。
 
-## def ridge
-L2正則化係数を用いて、L2正則化項の値を計算して取得します。
-### arguments
-なし。
-### return
-SFloat  
-L2正則化項の値を取得します。
-
 
 # class Dropout
 学習の際に、一部のノードを非活性化させるクラスです。
@@ -398,135 +357,49 @@ L2正則化項の値を取得します。
 * Float dropout_ration  
 ノードを非活性にする割合。
 
-## abstruct def forward(x)
-一部のノードを非活性にした上で、順方向に伝搬します。
-
-## abstruct def backward(dout)
-一部の非活性のノード以外の全てのノードを逆方向に伝搬します。
 
 # class BatchNormalization < HasParamLayer
 ミニバッチ単位でのデータの正規化を行います。
 
-## override def forward(x)
-正規化したデータを順方向に伝搬します。
-
-## override def backward(dout)
-正規化したデータを微分して、逆方向に伝搬します。
 
 # module Activations
 活性化関数のレイヤーの名前空間をなすモジュールです。
 
-# module SigmoidFunction
-シグモイド関数を提供するモジュールです。
-
-## def forward(x)
-シグモイド関数の値を順方向に伝搬します。
-### arguments
-SFloat x  
-シグモイド関数の引数。
-### return
-SFloat  
-シグモイド関数の戻り値
-
 
 # class Sigmoid < Layer
-## include SigmoidFunction
 シグモイド関数のレイヤーです。
 
-## override def forward(x)
-シグモイド関数の値を順方向に伝搬します。
-
-## def backward(dout)
-### arguments
-SFloat dout  
-シグモイド関数の導関数を適用した値を逆伝搬する。
-### return
-SFloat  
-シグモイド関数の導関数を適用した逆伝搬の値。
-
 
 # class Tanh < Layer
 tanh関数のレイヤーです。
-## def forward(x)
-tanh関数の値を順方向に伝搬します。
-### arguments
-SFloat x  
-tanh関数の引数。
-### return
-SFloat  
-tanh関数の戻り値
-
-## def backward(dout)
-### arguments
-SFloat dout  
-tanh関数の導関数を適用した値を逆伝搬する。
-### return
-SFloat  
-tanh関数の導関数を適用した逆伝搬の値。
 
 
 # class ReLU < Layer
 ランプ関数のレイヤーです。
-## def forward(x)
-ランプ関数の値を順方向に伝搬します。
-### arguments
-SFloat x  
-ランプ関数の引数。
-### return
-SFloat  
-ランプ関数の戻り値
-
-## def backward(dout)
-### arguments
-SFloat dout  
-ランプ関数の導関数を適用した値を逆伝搬する。
-### return
-SFloat  
-ランプ関数の導関数を適用した逆伝搬の値。
 
 
 # class LeakyReLU < Layer
 LeakyReLU関数のレイヤーです。
-## def forward(x)
-LeakyReLU関数の値を順方向に伝搬します。
-### arguments
-SFloat x  
-LeakyReLU関数の引数。
-### return
-SFloat  
-LeakyReLU関数の戻り値
 
-## def backward(dout)
+## 【Instance methods】
+
+## def initialize(alpha)
+コンストラクタ。
 ### arguments
-SFloat dout  
-LeakyReLU関数の導関数を適用した値を逆伝搬する。
-### return
-SFloat  
-LeakyReLU関数の導関数を適用した逆伝搬の値。
+* Float alpha  
+出力値が負のときの傾き。
 
 
 # class IdentityWithLoss < OutputLayer
 恒等関数と二乗誤差関数を合わせた出力層のレイヤーです。
-## override def forward(x)
-データをそのまま順方向に伝搬します。
-## override def backward(y)
-恒等関数と二乗誤差関数を合わせたものを微分した導関数を用いて、教師データの出力データを逆方向に伝搬します。
 
 
 # class SoftmaxWithLoss < OutputLayer
 ソフトマックス関数とクロスエントロピー誤差関数を合わせた出力層のレイヤーです。
-## override def forward(x)
-ソフトマックス関数の値を順方向に伝搬します。
-## override def backward(y)
-ソフトマックス関数とクロスエントロピー誤差関数を合わせたものを微分した導関数を用いて、教師データの出力データを逆方向に伝搬します。
 
 
 # class SigmoidWithLoss < OutputLayer
 シグモイド関数とバイナリクロスエントロピー誤差関数を合わせた出力層のレイヤーです。
-## override def forward(x)
-シグモイド関数の値を順方向に伝搬します。
-## override def backward(y)
-シグモイド関数とバイナリクロスエントロピー誤差関数を合わせたものを微分した導関数を用いて、教師データの出力データを逆方向に伝搬します。
 
 
 # module Initializers
@@ -550,36 +423,25 @@ LeakyReLU関数の導関数を適用した逆伝搬の値。
 # class Zeros < Initializer
 パラメータを0で初期化します。
 
-## override def init_param(layer, param_key)
-レイヤーの持つパラメータを0で初期化します。
 
 # class RandomNormal < Initializer
 パラメータを正規分布による乱数で初期化します。
 
 ## def initialize(mean = 0, std = 0.05)
 ### arguments
-Float mean = 0  
-正規分布の平均。
-Float std = 0.05  
-正規分布の分散。
-
-## override def init_param(layer, param_key)
-レイヤーの持つパラメータを正規分布による乱数で初期化します。
+* Float mean = 0  
+  正規分布の平均。
+* Float std = 0.05  
+  正規分布の分散。
 
 
 # class Xavier < Initializer
 パラメータをXavierの初期値で初期化します。
 
-## override def init_param(layer, param_key)
-レイヤーの持つパラメータをXavierの初期値で初期化します。
-
 
 # class He < Initializer
 パラメータをHeの初期値で初期化します。
 
-## override def init_param(layer, param_key)
-レイヤーの持つパラメータをHeの初期値で初期化します。
-
 
 # module Optimizers
 全てのOptimizerの名前空間をなすモジュールです。
@@ -599,14 +461,14 @@ Float learning_rate
 ## def initialize(learning_rate)
 コンストラクタ。
 ### arguments
-Float learning_rate  
-Optimizerの学習率。
+* Float learning_rate  
+  Optimizerの学習率。
 
 ## abstruct def update(layer)
-layerのgradsを元に、layerのparamsを更新します。
+layerのgradsを元に、layerのparamsを更新します。全てのOptimizerを継承するクラスは、このメソッドを実装する必要があります。
 ### arguments
-Layer layer  
-paramsを更新するレイヤー。
+* Layer layer  
+  paramsを更新するレイヤー。
 ### return
 なし。
 
@@ -622,13 +484,13 @@ Float momentum
 
 ## 【Instance methods】
 
-## override def initialize(learning_rate = 0.01, momentum: 0)
+## def initialize(learning_rate = 0.01, momentum: 0)
 コンストラクタ。
 ### arguments
-Float learning_rate  
-学習率。
-Float momentum  
-モーメンタム係数。
+* Float learning_rate  
+  学習率。
+* Float momentum  
+  モーメンタム係数。
 
 
 # class AdaGrad < Optimizer
@@ -644,6 +506,16 @@ RMSPropによるオプティマイザです。
 Float muse  
 指数平均移動のための係数。
 
+## 【Instance methods】
+
+## def initialize(learning_rate = 0.001, muse = 0.9)
+コンストラクタ。
+### arguments
+* Float learning_rate  
+  学習率。
+* Float muse  
+  指数平均移動のための係数。
+
 
 # class Adam < Optimizer
 Adamによるオプティマイザです。
@@ -658,6 +530,16 @@ Float beta1
 Float beta2
 指数平均移動のための係数2。
 
+## 【Instance methods】
+
+## def initialize(learning_rate = 0.001, beta1 = 0.9, beta2 = 0.999)
+コンストラクタ。
+### arguments
+* Float beta1
+  指数平均移動のための係数1。
+* Float beta2
+  指数平均移動のための係数2。
+
 
 # module Util
 ユーティリティ関数を提供します。
@@ -667,12 +549,12 @@ Float beta2
 ## def self.get_minibatch(x, y, batch_size)
 batch_size分のミニバッチを取得します。
 ### arguments
-SFloat x  
-教師データの入力データ。
-SFloat y  
-教師データの出力データ。
-Integer batch_size  
-ミニバッチのサイズ。
+* SFloat x  
+  教師データの入力データ。
+* SFloat y  
+  教師データの出力データ。
+* Integer batch_size  
+  ミニバッチのサイズ。
 ### return
 Array  
 [xのミニバッチ, yのミニバッチ]の形式の配列を返します。
@@ -680,23 +562,12 @@ Array
 ## def self.to_categorical(y, num_classes, type = nil)
 ラベルをnum_classesのベクトルにカテゴライズします。
 ### arguments
-SFloat y  
-教師データの出力データ。
-Integer num_classes  
-カテゴライズするクラス数。
-NArray narray_type = nil  
-カテゴライズしたNArrayデータの型。nilを指定すると、yの型を使用します。
+* SFloat y  
+  教師データの出力データ。
+*  Integer num_classes  
+  カテゴライズするクラス数。
+*  NArray narray_type = nil  
+  カテゴライズしたNArrayデータの型。nilを指定すると、yの型を使用します。
 ### return
 NArray  
 カテゴライズされたNArrayのインスタンス。
-
-## def self.numerical_grad(x, func)
-引数で渡された関数を数値微分します。
-### arguments
-SFloat x  
-funcの引数。
-Proc|Method func  
-数値微分を行う対象の関数。
-### return
-SFloat  
-数値微分した結果の値。

data/lib/dnn/core/activations.rb

@@ -50,13 +50,19 @@ module DNN
 
 
     class LeakyReLU < Layer
+      include Numo
+
       def initialize(alpha = 0.3)
         @alpha = alpha
       end
 
+      def self.load_hash(hash)
+        self.new(hash[:alpha])
+      end
+
       def forward(x)
         @x = x.clone
-        a = Numo::SFloat.ones(x.shape)
+        a = SFloat.ones(x.shape)
         a[x <= 0] = @alpha
         x * a
       end
@@ -66,6 +72,10 @@ module DNN
         @x[@x <= 0] = @alpha
         dout * @x
       end
+
+      def to_hash
+        {name: self.class.name, alpha: alpha}
+      end
     end
 
 
@@ -79,7 +89,8 @@ module DNN
       end
     
       def loss(y)
-        0.5 * ((@out - y) ** 2).sum / @model.batch_size + ridge
+        batch_size = y.shape[0]
+        0.5 * ((@out - y) ** 2).sum / batch_size + ridge
       end
     end
     
@@ -94,7 +105,8 @@ module DNN
       end
     
       def loss(y)
-        -(y * NMath.log(@out + 1e-7)).sum / @model.batch_size + ridge
+        batch_size = y.shape[0]
+        -(y * NMath.log(@out + 1e-7)).sum / batch_size + ridge
       end
     end
 
@@ -108,7 +120,8 @@ module DNN
       end
 
       def loss(y)
-        -(y * NMath.log(@out + 1e-7) + (1 - y) * NMath.log(1 - @out + 1e-7)).sum / @model.batch_size + ridge
+        batch_size = y.shape[0]
+        -(y * NMath.log(@out + 1e-7) + (1 - y) * NMath.log(1 - @out + 1e-7)).sum / batch_size + ridge
       end
     end
 

data/lib/dnn/core/initializers.rb

@@ -5,6 +5,10 @@ module DNN
       def init_param(layer, param_key, param)
         layer.params[param_key] = param
       end
+
+      def to_hash
+        {name: self.class.name}
+      end
     end
 
 
@@ -16,14 +20,22 @@ module DNN
     
     
     class RandomNormal < Initializer
+      def self.load_hash(hash)
+        self.new(hash[:mean], hash[:std])
+      end
+
       def initialize(mean = 0, std = 0.05)
         @mean = mean
         @std = std
       end
-    
+
       def init_param(layer, param_key)
         super(layer, param_key, layer.params[param_key].rand_norm(@mean, @std))
       end
+
+      def to_hash
+        {name: self.class.name, mean: @mean, std: @std}
+      end
     end
     
     

data/lib/dnn/core/layers.rb

@@ -20,6 +20,11 @@ module DNN
       def shape
         prev_layer.shape
       end
+
+      #Layer to a hash.
+      def to_hash
+        {name: self.class.name}
+      end
     
       #Get the previous layer.
       def prev_layer
@@ -56,7 +61,11 @@ module DNN
     
     class InputLayer < Layer
       attr_reader :shape
-    
+
+      def self.load_hash(hash)
+        self.new(hash[:shape])
+      end
+
       def initialize(dim_or_shape)
         @shape = dim_or_shape.is_a?(Array) ? dim_or_shape : [dim_or_shape]
       end
@@ -68,6 +77,10 @@ module DNN
       def backward(dout)
         dout
       end
+
+      def to_hash
+        {name: self.class.name, shape: @shape}
+      end
     end
     
     
@@ -87,6 +100,13 @@ module DNN
         @bias_initializer = (bias_initializer || Zeros.new)
         @weight_decay = weight_decay
       end
+
+      def self.load_hash(hash)
+        self.new(hash[:num_nodes],
+                 weight_initializer: Util.load_hash(hash[:weight_initializer]),
+                 bias_initializer: Util.load_hash(hash[:bias_initializer]),
+                 weight_decay: hash[:weight_decay])
+      end
     
       def forward(x)
         @x = x
@@ -106,6 +126,16 @@ module DNN
       def shape
         [@num_nodes]
       end
+
+      def to_hash
+        {
+          name: self.class.name,
+          num_nodes: @num_nodes,
+          weight_initializer: @weight_initializer.to_hash,
+          bias_initializer: @bias_initializer.to_hash,
+          weight_decay: @weight_decay,
+        }
+      end
     
       private
     
@@ -178,8 +208,17 @@ module DNN
         @weight_initializer = (weight_initializer || RandomNormal.new)
         @bias_initializer = (bias_initializer || Zeros.new)
         @strides = strides
-        @weight_decay = weight_decay
         @padding = padding
+        @weight_decay = weight_decay
+      end
+
+      def self.load_hash(hash)
+        Conv2D.new(hash[:num_filters], hash[:filter_height], hash[:filter_width],
+                   weight_initializer: Util.load_hash(hash[:weight_initializer]),
+                   bias_initializer: Util.load_hash(hash[:bias_initializer]),
+                   strides: hash[:strides],
+                   padding: hash[:padding],
+                   weight_decay: hash[:weight_decay])
       end
     
       def init(model)
@@ -213,6 +252,20 @@ module DNN
       def shape
         [@num_filters, @out_height, @out_width]
       end
+
+      def to_hash
+        {
+          name: self.class.name,
+          num_filters: @num_filters,
+          filter_height: @filter_height,
+          filter_width: @filter_width,
+          weight_initializer: @weight_initializer.to_hash,
+          bias_initializer: @bias_initializer.to_hash,
+          strides: @strides,
+          padding: @padding,
+          weight_decay: @weight_decay,
+        }
+      end
     
       private
     
@@ -264,6 +317,16 @@ module DNN
       def shape
         [@num_channel, @out_height, @out_width]
       end
+
+      def to_hash
+        {
+          name: self.class.name,
+          pool_height: @pool_height,
+          pool_width: @pool_width,
+          strides: @strides,
+          padding: @padding,
+        }
+      end
     end
     
     
@@ -291,6 +354,10 @@ module DNN
         @x_shape = nil
       end
 
+      def self.load_hash(hash)
+        self.new(hash[:shape])
+      end
+
       def forward(x)
         @x_shape = x.shape
         x.reshape(*@shape)
@@ -299,6 +366,10 @@ module DNN
       def backward(dout)
         dout.reshape(@x_shape)
       end
+
+      def to_hash
+        {name: self.class.name, shape: @shape}
+      end
     end
 
 
@@ -317,6 +388,10 @@ module DNN
         @dropout_ratio = dropout_ratio
         @mask = nil
       end
+
+      def self.load(hash)
+        self.new(hash[:dropout_ratio])
+      end
     
       def forward(x)
         if @model.training
@@ -346,22 +421,23 @@ module DNN
       end
     
       def backward(dout)
+        batch_size = dout.shape[0]
         @grads[:beta] = dout.sum(0)
         @grads[:gamma] = (@xn * dout).sum(0)
         dxn = @params[:gamma] * dout
         dxc = dxn / @std
         dstd = -((dxn * @xc) / (@std**2)).sum(0)
         dvar = 0.5 * dstd / @std
-        dxc += (2.0 / @model.batch_size) * @xc * dvar
+        dxc += (2.0 / batch_size) * @xc * dvar
         dmean = dxc.sum(0)
-        dxc - dmean / @model.batch_size
+        dxc - dmean / batch_size 
       end
     
       private
     
       def init_params
-        @params[:gamma] = 1
-        @params[:beta] = 0
+        @params[:gamma] = SFloat.ones(*shape)
+        @params[:beta] = SFloat.zeros(*shape)
       end
     end
   end

data/lib/dnn/core/model.rb

@@ -1,25 +1,65 @@
+require "json"
+require "base64"
+
 module DNN
   class Model
-    attr_reader :layers
+    include Numo
+    
+    attr_accessor :layers
     attr_reader :optimizer
     attr_reader :batch_size
     attr_reader :training
   
-    def self.load(file_name)
-      Marshal.load(File.binread(file_name))
-    end
-  
     def initialize
       @layers = []
       @optimizer = nil
       @batch_size = nil
     end
+
+    def self.load(file_name)
+      Marshal.load(File.binread(file_name))
+    end
+
+    def self.load_json(json_str)
+      hash = JSON.parse(json_str, symbolize_names: true)
+      model = self.new
+      model.layers = hash[:layers].map { |hash_layer| Util.load_hash(hash_layer) }
+      model.compile(Util.load_hash(hash[:optimizer]))
+      model
+    end
+
+    def load_json_params(json_str)
+      has_param_layers_params = JSON.parse(json_str, symbolize_names: true)
+      has_param_layers_index = 0
+      @layers.each do |layer|
+        next unless layer.is_a?(HasParamLayer)
+        hash_params = has_param_layers_params[has_param_layers_index]
+        hash_params.each do |key, param|
+          layer.params[key] = SFloat.cast(param)
+        end
+        has_param_layers_index += 1
+      end
+    end
   
     def save(file_name)
       dir_name = file_name.match(%r`(.*)/.+$`)[1]
       Dir.mkdir(dir_name) unless Dir.exist?(dir_name)
       File.binwrite(file_name, Marshal.dump(self))
     end
+
+    def to_json
+      hash_layers = @layers.map { |layer| layer.to_hash }
+      hash = {version: VERSION, layers: hash_layers, optimizer: @optimizer.to_hash}
+      JSON.dump(hash)
+    end
+    
+    def params_to_json
+      has_param_layers = @layers.select { |layer| layer.is_a?(HasParamLayer) }
+      has_param_layers_params = has_param_layers.map do |layer|
+        layer.params.map { |key, param| [key, param.to_a] }.to_h
+      end
+      JSON.dump(has_param_layers_params)
+    end
   
     def <<(layer)
       unless layer.is_a?(Layers::Layer)

data/lib/dnn/core/optimizers.rb

@@ -11,6 +11,10 @@ module DNN
 
       #Update layer has params.
       def update(layer) end
+
+      def to_hash
+        {name: self.class.name, learning_rate: @learning_rate}
+      end
     end
 
 
@@ -22,6 +26,10 @@ module DNN
         @momentum = momentum
         @amounts = {}
       end
+
+      def self.load_hash(hash)
+        self.new(hash[:learning_rate], hash[:momentum])
+      end
     
       def update(layer)
         amount = if @amounts[layer]
@@ -39,6 +47,14 @@ module DNN
           layer.params[key] -= amount[key]
         end
       end
+
+      def to_hash
+        {
+          name: self.class.name,
+          learning_rate: @learning_rate,
+          momentum: @momentum,
+        }
+      end
     end
     
     
@@ -47,6 +63,10 @@ module DNN
         super(learning_rate)
         @g = {}
       end
+
+      def self.load_hash(hash)
+        @learning_rate = hash[:learning_rate]
+      end
     
       def update(layer)
         @g[layer] ||= {}
@@ -67,6 +87,10 @@ module DNN
         @muse = muse
         @g = {}
       end
+
+      def self.load_hash(hash)
+        self.new(hash[:learning_rate], hash[:muse])
+      end
     
       def update(layer)
         @g[layer] ||= {}
@@ -76,6 +100,14 @@ module DNN
           layer.params[key] -= (@learning_rate / NMath.sqrt(@g[layer][key] + 1e-7)) * layer.grads[key]
         end
       end
+
+      def to_hash
+        {
+          name: self.class.name,
+          learning_rate: @learning_rate,
+          muse: @muse,
+        }
+      end
     end
 
 
@@ -94,6 +126,10 @@ module DNN
         @v = {}
       end
 
+      def self.load_hash(hash)
+        self.new(hash[:learning_rate], hash[:beta1], hash[:beta2])
+      end
+
       def update(layer)
         @iter += 1
         @m[layer] ||= {}
@@ -107,6 +143,15 @@ module DNN
           layer.params[key] -= lr * @m[layer][key] / NMath.sqrt(@v[layer][key] + 1e-7)
         end
       end
+
+      def to_hash
+        {
+          name: self.class.name,
+          learning_rate: @learning_rate,
+          beta1: @beta1,
+          beta2: @beta2,
+        }
+      end
     end
 
   end

data/lib/dnn/core/util.rb

@@ -20,5 +20,14 @@ module DNN
     def self.numerical_grad(x, func)
       (func.(x + 1e-7) - func.(x)) / 1e-7
     end
+
+    #Convert hash to an object.
+    def self.load_hash(hash)
+      dnn_class = DNN.const_get(hash[:name])
+      if dnn_class.respond_to?(:load_hash)
+        return dnn_class.load_hash(hash)
+      end
+      dnn_class.new
+    end
   end
 end

data/lib/dnn/core/version.rb

@@ -1,3 +1,3 @@
 module DNN
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

data/ruby-dnn.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{ruby deep learning library.}
   spec.description   = %q{ruby-dnn is a ruby deep learning library.}
-  spec.homepage      = "https://github.com/unagiootoro/dnn.git"
+  spec.homepage      = "https://github.com/unagiootoro/ruby-dnn.git"
   spec.license       = "MIT"
   spec.extensions    = ["lib/dnn/ext/mnist/extconf.rb", "lib/dnn/ext/cifar10/extconf.rb", "lib/dnn/ext/image_io/extconf.rb"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-dnn
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - unagiootoro
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-04 00:00:00.000000000 Z
+date: 2018-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -212,7 +212,7 @@ files:
 - lib/dnn/lib/image_io.rb
 - lib/dnn/lib/mnist.rb
 - ruby-dnn.gemspec
-homepage: https://github.com/unagiootoro/dnn.git
+homepage: https://github.com/unagiootoro/ruby-dnn.git
 licenses:
 - MIT
 metadata: {}