3. APIs

3.1. パッケージ

3.1.1. Layer

class renom.layers. layer

Layerクラスは全てのニューラルネットワークオブジェクトが継承するAbstructクラスです。順伝播、逆伝播、 重みの更新を行う時に呼び出される関数が宣言されています。

__init__ ( layer = None , unit = 0 , weight_decay = None , initial_weight_scale = 1.0 , initial_weight = None , initial_bias = None , print_status = False )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • unit ( int ) – この層のユニット数を表します。
  • weight_decay ( float32 ) – 重み減衰の強さを制御するパラメータです
  • initial_weight_scale ( float32 ) – 初期重みを与える正規分布の標準偏差です。
  • initial_weight ( ndarray ) – 重みをinitial_weightで初期化します
  • initial_bias ( ndarray ) – バイアスをinitial_biasで初期化します
  • print_status ( bool ) – インスタンス化時に層の情報を出力します。
unit ( )

この層のユニット数を取得します。

戻り値: ユニット数
戻り値の型: int
forward ( x , y = None )

学習時の順伝播計算を実行します。

パラメータ:
  • x ( ndarray ) – 層への入力です。(入力フォーマット参照)
  • y ( ndarray ) – 教師データです。
戻り値:

層の出力。

戻り値の型:

ndarray

backward ( dy = None )

逆伝播計算を実行します。

パラメータ:
  • dx ( ndarray ) – 一つ後ろの層より伝播された誤差です。
  • dy ( ndarray ) – 二つ後ろの層より伝播された誤差です。
戻り値:

この層で計算された誤差を返します。

戻り値の型:

ndarray

predict ( x )

学習した重みを用いて、予測を行います

パラメータ: x ( ndarray ) – 予測するデータを入力します。
戻り値: 予測結果
戻り値の型: ndarray
update ( opt_hook = hook )

この層の重み、バイアスパラメーラを更新します。

パラメータ: opt_hook ( function ) – Optimizerに定義されている勾配降下アルゴリズム。
戻り値: None
truncate ( )

時系列方向の誤差伝播を打ち切ります。

parameter ( )

重みとバイアスを取得します。戻り値は、辞書型になっており、キーワードを指定することで、特定のパラメータを得ます。具体的には次のように、重み、バイアスパラメータを取得します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
from renom.layers.function.dense import Dense
input_layer = Input(2)                  # 入力側レイヤ
middle_layer = Dense(input_layer, 3)    # 出力側レイヤ

params = middle_layer.parameter         # 中間層のパラメータを持つ辞書を取得

print params.keys()                     # キーの確認
# ['b','w']


print params["w"]                       # 重みの表示
# [[-0.17000207 -0.28976062 0.49116576]
#  [ 0.12199184 -0.78273273 0.17504749]]

print params["b"]                       # バイアスの表示
# [ 0. 0. 0.]

また、事前学習で得た重みを他のレイヤにコピーする場合も、 この関数を使います。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from renom.layers.function.input import Input
from renom.layers.function.dense import Dense

layerA1 = Input(2)                      # 入力側レイヤ A
layerA2 = Dense(layerA1, 3)             # 出力側レイヤ A
print(layerA2.parameter["w"])           # 重みを確認

# [[-0.2280812 1.38808405 -0.49226165]
#  [-0.96478164 -0.46317109 -0.02896073]]

layerB1 = Input(2)                      # 入力側レイヤ B
layerB2 = Dense(layerB1, 3)             # 出力側レイヤ B
print(layerB2.parameter["w"])           # 重みを確認

# [[-0.22626245 -0.63719499 -1.26402092]
#  [-0.30360234 -0.80557466 0.26039949]]

layerA2.parameter = layerB2.parameter   # パラメータのコピー

print(layerA2.parameter["w"])

# [[-0.22626245 -0.63719499 -1.26402092]
#  [-0.30360234 -0.80557466 0.26039949]]
戻り値: 重みとバイアス
戻り値の型: dict
z ( )

各層の出力を次のコードのように取得します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
import numpy
from renom.layers.function.input import Input
from renom.layers.function.dense import Dense
from renom.layers.activation.sigmoid import Sigmoid
from renom.optimizers.sgd import Sgd

data = numpy.array([[1, 0], [0, 1]])    # 入力データ

layer1 = Input(2)                       # 入力層の定義
layer2 = Dense(layer1, 3)               # 出力層の定義

activate = Sigmoid(layer2)              # 出力層の活性化関数

opt = Sgd( layer1, activate )           # オプティマイザ

print(opt.predict(data))                # activate の出力
# [[ 0.18351557 0.72389466 0.65767443]
#  [ 0.60547967 0.68729198 0.39738587]]

print(layer2.z)                         #layer2 の出力
# [[-1.49270833 0.96386343 0.65294778]
#  [ 0.4283503 0.7874893 -0.41636932]]
戻り値: 各層の順伝播時の出力
戻り値の型: ndarray

3.1.2. Activate

class renom.layers.activation. activate

Activateクラスは、Layerクラスを継承している抽象クラスです。すべての活性化関数はActivate クラスを継承しています。

__init__ ( layer = None )
パラメータ: layer ( Layer ) – この層に値を渡す層を引数としてとります。

活性化関数は次のようにして、ニューラルネットワークへ組み込むことができます。

input_layer = Input(2)                  # 第一層の定義
middle_layer = Dense(input_layer, 3)    # 第二層の定義
activate = Tanh( layer2 )               # 第二層の活性化関数

3.1.3. Tanh

class renom.layers.activation. tanh

Activate ⇐ Tanh

次の式で表される活性化関数を定義しているクラスです

z=\tanh(x)

3.1.4. Sigmoid

class renom.layers.activation. sigmoid

Activate ⇐ Sigmoid

次式で表される活性化関数を定義しているクラスです。

z=\frac{1}{1-e^{-x}}

3.1.5. Clipped_relu

class renom.layers.activation. clipped_relu

Activate ⇐ Clipped_relu

次式で表される活性化関数を定義しているクラスです。

z = min(max(x, 0), c)
__init__ ( layer = None , c = 20.0 )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • c ( float32 ) – 活性化関数に使用する引数です。(クリッピング値)

3.1.6. Elu

class renom.layers.activation. elu

Activate ⇐ Elu

次式で表される活性化関数を定義しているクラスです。 [7]

\begin{split}\begin{split} z &=\cases{x&\text{(if $x\geq0$)}\cr a(e^{x}-1)&\text{(if $x<0$)} } \end{split}\end{split}
__init__ ( layer = None , a = 0.5 )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • a ( float32 ) – 活性化関数に使用する引数です。

3.1.7. Leaky_relu

class renom.layers.activation. leaky_relu

Activate ⇐ Leaky_Relu

次の式で表される活性化関数を定義しているクラスです。

z=max(x, ax)
_init__ ( layer = None , a = 0.2 )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • a ( float32 ) – 活性化関数に使用する引数です。

3.1.8. Relu

class renom.layers.activation. relu

Activate ⇐ Relu

次の式で表される活性化関数を定義しているクラスです。

\begin{split}z&=max(x, 0)\end{split}

3.1.9. Model

class renom.model. model

ニューラルネットワーク構造が定義されたクラスです。

__init__ ( in_layer , out_layer )
パラメータ:
  • in_layer ( Layer ) – 入力層のレイヤです。
  • out_layer ( Layer ) – 出力層のレイヤです。
forward ( x , y = None )

学習時の順伝播計算を実行します

パラメータ:
  • x ( ndarray ) – 層への入力です。(入力フォーマット参照)
  • y ( ndarray ) – 教師データです。
戻り値:

目的関数の出力

戻り値の型:

ndarray

backward ( dx = None )

逆伝播計算を実行します。

predict ( x )

順伝播計算を実行します。

パラメータ: x ( ndarray ) – 層への入力を表します。(入力フォーマット参照)
戻り値: ネットワークの出力
戻り値の型: ndarray
update ( )

重みの更新を行います。

3.1.10. Optimizer

class renom.layers.optimizers. optimizer

ユーザが定義した ニューラルネットワークについて,順伝播,逆伝播,重みの更新を行うクラスです。Optimizerクラスを継承したクラスをインスタンス化するには、定義したニューラルネットワークの入力層と出力層をコンストラクタに与えます。

input_layer = Input(784)                        # 入力層の定義
middle_layer = Dense( input_layer, 100 )        # 中間層の定義
activate = Sigmoid( middle_layer )              # 中間層の活性化関数
output_layer = Dense ( activate, 10 )           # 出力層
loss = Soft_Max_Cross_Entropy( output_layer )   # 誤差関数
opt = Sgd( Model( input_layer, loss) )          # 勾配降下法の定義

Optimizerを継承したクラスには、それぞれ固有の重み更新アルゴリズムを定義しています。

__init__ ( model , lr=0.1 )
パラメータ:
  • model ( Model ) – ニューラルネットワークモデル
  • lr ( float32 ) – 学習率
hook ( )

目的関数の勾配から、重み、バイアスパラメータの更新量を求めます。

パラメータ: params ( dict ) – 重み、バイアスのパラメータ値です。
戻り値: 重み、バイアスの更新量
戻り値の型: dict
forward ( x , y = None )

学習時の順伝播計算を実行します

パラメータ:
  • x ( ndarray ) – 層への入力です。(入力フォーマット参照)
  • y ( ndarray ) – 教師データです。
戻り値:

目的関数の出力

戻り値の型:

ndarray

backward ( dx = None )

逆伝播計算を実行します。

predict ( x )

順伝播計算を実行します。

パラメータ: x ( ndarray ) – 層への入力を表します。(入力フォーマット参照)
戻り値: ネットワークの出力
戻り値の型: ndarray

3.1.11. Sgd

class renom.layers.optimizers. sgd

Optimizer ⇐ Sgd

ユーザが定義したニューラルネットワークについて、順伝播、逆伝播、重みの更新を行うクラスです。重み更新のアルゴリズムとして、次の式で表される更新式を実装しています。

w: 現在の重み
gw: 目的関数の勾配
lr: 学習率
w\leftarrow w-gw\cdot lr
__init__ ( model , lr=0.1 )
パラメータ:
  • model ( Model ) – ニューラルネットワークモデル
  • lr ( float32 ) – 学習率を表します。

3.1.12. Momentum_sgd

class renom.layers.optimizers. momentum_sgd

Optimizer ⇐ Momentum_sgd

ユーザが定義したニューラルネットワークについて、順伝播、逆伝播、重みの更新を行うクラスです。重み更新のアルゴリズムとして、次の式で表される更新式を実装しています。

w: 現在の重み
pw: 前回更新前の重み
gw: 目的関数の勾配
lr: 学習率
momentum: モメンタム係数
w\leftarrow w-gw\cdot lr+pw\cdot momentum
__init__ ( model , lr=0.1 , momentum=0.01 )
パラメータ:
  • model ( Model ) – ニューラルネットワークモデル
  • lr ( float32 ) – 学習率
  • momentum ( float32 ) – モメンタム係数

3.1.13. Adagrad

class renom.layers.optimizers. adagrad

Optimizer ⇐ Adagrad

ユーザが定義したニューラルネットワークについて、順伝播、逆伝播、重みの更新を行うクラスです。重み更新のアルゴリズムとして、次の式で表される更新式を実装しています。 [8]

w: 現在の重み
gw: 目的関数の勾配
lr: 学習率
\varepsilon : 安定のためのパラメータ( 10^{8} )
\begin{split}r\leftarrow r+ gw^{2}\\w\leftarrow w-\frac{lr}{\sqrt{r}+{\varepsilon}}\cdot gw\end{split}
__init__ ( model , lr=0.1 )
パラメータ:
  • model ( Model ) – ニューラルネットワークモデル
  • lr ( float32 ) – 学習率を表します。

3.1.14. Adam

class renom.layers.optimizers. adam

Optimizer ⇐ Adam

ユーザが定義したニューラルネットワークについて、順伝播、逆伝播、重みの更新を行うクラスです。重み更新のアルゴリズムとして、次の式で表される更新式を実装しています。 [9]

w: 現在の重み
g: ハイパーパラメータ(0<g<1)
b: ハイパーパラメータ(0<b<1)
gw: 目的関数の勾配
b: 学習率
t: 更新回数
\varepsilon : 安定のためのパラメータ(10^8 )
\begin{split}v\leftarrow b\cdot v+(1-b)\cdot gw\\r\leftarrow g\cdot r+(1-g)\cdot gw^{2}\\w\leftarrow w-\frac{lr}{\sqrt{\frac{r}{1-r^{2}}+\varepsilon}}\cdot \frac{v}{1-\beta^{2}}\end{split}
__init__ ( model , lr=0.1 , g=0.999 , b=0.9 )
パラメータ:
  • model ( Model ) – ニューラルネットワークモデル
  • lr ( float32 ) – 学習率を表します。
  • g ( float32 ) – 更新の計算に必要なパラメータ値です。
  • b ( float32 ) – 更新の計算に必要なパラメータ値です。

3.1.15. Adadelta

class renom.layers.optimizers. adadelta

Optimizer ⇐ Adadelta

ユーザが定義したニューラルネットワークについて、順伝播、逆伝播、重みの更新を行うクラスです。重み更新のアルゴリズムとして、次の式で表される更新式を実装しています。 [10]

w: 現在の重み
g: ハイパーパラメータ(0<g<1)
gw: 目的関数の勾配
\epsilon : 安定のためのパラメータ( 10^{8} )
\begin{split}r\leftarrow g\cdot r+(1-g)\cdot gw^{2}\\v\leftarrow v-\frac{\sqrt{s}+\epsilon}{\sqrt{r}+\epsilon}\cdot w\\s\leftarrow g\cdot s+(1-g)\cdot v^{2}\\w\leftarrow w-v\end{split}
__init__ ( model , lr = 0.1 , g = 0.95 )
パラメータ:
  • model ( Model ) – ニューラルネットワークモデル
  • lr ( float32 ) – 学習率を表します。
  • g ( float32 ) – 更新の計算に必要なパラメータ値です。

3.1.16. Rmsprop

class renom.layers.optimizers. rmsprop

Optimizer ⇐ Rmsprop

ユーザが定義したニューラルネットワークについて、順伝播、逆伝播、重みの更新を行うクラスです。重み更新のアルゴリズムとして、次の式で表される更新式を実装しています。 [11]

w: 現在の重み
g: ハイパーパラメータ (0\leq g\leq1)
gw: 目的関数の勾配
\varepsilon : 安定のためのパラメータ( 10^{8} )
\begin{split}r\leftarrow g\cdot r+(1-g)\cdot gw^{2}\\w\leftarrow w-\frac{lr}{\sqrt{r}+\epsilon}\cdot w\end{split}
__init__ ( model , lr = 0.1 , g = 0.99 )
パラメータ:
  • model ( Model ) – ニューラルネットワークモデル
  • lr ( float32 ) – 学習率を表します。
  • g ( float32 ) – 更新の計算に必要なパラメータ値です。

3.1.17. CD_Method

class renom.bm. cd_method
p(x_{n}|\theta) : パラメータθにより決定されるデータxを生成する分布を表す関数
v_{i}^{t} : t回サンプリングした後のi番目の隠れ変数の値
h_{j}^{t} : t回サンプリングした後のj番目の隠れ変数の値
a_{j} : 可視変数と同数のバイアス隠れ変数と同数のバイアス
b_{j} : 隠れ変数と同数のバイアス
w_{ij} :i番目の可視変数とj番目の隠れ変数を結ぶ重み
T: サンプリング回数
lr: 学習率
\begin{split} L(\theta)=\prod_{n=1}^N p(x_n\mid\theta) \end{split}
この尤度関数を最大化することを目的とします。ここではCD法を使用します。可視変 数と隠れ変数のサンプリング回数は1回としています。(T = 1)
重みの更新量は
\begin{split} \triangle w_{ij}=v_{i}^{(0)}-p_{j}^{(0)}-v_{j}^{(T)}p_{j}^{(T)} \end{split}

と計算しています。(ここで、 p_{j}^{(t)}=P(h_{j}=1|V^{(T)},\theta))

バイアスにおいても同様に、

\begin{split}\begin{split} \triangle a_{i}=v_{i}^{(0)}-v_{j}^{(T)}\\ \triangle b_{j}=p_{i}^{(0)}-p_{j}^{(T)} \end{split}\end{split}

と計算しています。新たな重みは

\begin{split} wg\leftarrow lr\cdot \triangle w_{ij} \end{split}

となります。バイアスも同様に計算します。

__init__ ( visible_layer , hidden_layer , lr=0.1 )
パラメータ:
  • visible_layer ( Layer ) – 可視層としてLayerオブジェクトを引数にとります。
  • hidden_layer ( Layer ) – 隠れ層としてLayerオブジェクトを引数にとります。
  • lr ( float32 ) – 学習率を表します。
train ( x )

パラメータを更新し結果を出力します。

パラメータ: x ( ndarray ) – 可視層に入力するデータです。
戻り値: ボルツマンマシンの出力と入力データ間の二乗誤差
戻り値の型: float32
visible_to_hidden ( x )
パラメータ: x ( ndarray ) – 可視層に入力するデータです。
戻り値: 推定した隠れ層の状態
戻り値の型: float32
hidden_to_visible ( x )

隠れ層の状態から可視層の状態を推定します。

パラメータ: x ( ndarray ) – 隠れ層に入力するデータです。
戻り値: 推定した可視層の状態
戻り値の型: float32
update ( hook=None )

train関数により求められた目的関数の勾配を用いて、重みを更新します。

パラメータ: hook ( function ) – Optimizerに定義されている勾配降下アルゴリズム。

3.1.18. Rnn

class renom.layers.function. rnn

Layer ⇐ Rnn

再帰型ニューラルネットワークを実現します。学習方法にはBPTT法を使用しています。 [6]

以下の式で定義される順伝播計算を実行します。
t: 時刻
x_{j}^{t} : 時刻tにおける出力
z_{j}^{t} : 時刻tにおける次の層への出力
w_{ii}^{(in)} : 前の層と、この層の結合重み
w_{jj'} : 中間層から次時刻の中間層への結合重み
f: 活性化関数
\begin{split} z_{j}^{t}=\sum_{i}w_{ji}^{(in)}\cdot x_{i}+\sum_{j'}w_{jj'}\cdot f(z_{j'}^{t-1}) \end{split}
_init_ ( layer=None , unit=0 , weight_decay=None , initial_weight_scale=1.0 , print_status=False )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • unit ( int ) – ユニット数を表します。
  • weight_decay ( float32 ) – 正則化の強さを制御するパラメータです。
  • initial_weight_scale ( float32 ) – 初期重みを与える正規分布の標準偏差です。
  • print_status ( bool ) – インスタンス化時に層の情報を出力します。
forward ( x , y )

学習時の順伝播計算を実行します。

パラメータ:
  • x ( ndarray ) – 層への入力です。(入力フォーマット参照)
  • y ( ndarray ) – 教師用データです。
戻り値:

層の出力

戻り値の型:

ndarray

backward ( dy = None )

逆伝播計算を実行します。

パラメータ: dy ( ndarray ) – 一つ後ろの層より伝播された誤差です。
戻り値: この層で計算された誤差
戻り値の型: ndarray
turncate ( )

時系列の誤差伝播を打ち切ります。

predict ( )

順伝播計算を実行します。

パラメータ: x ( ndarray ) – 予測するデータを入力します。(入力フォーマット参照)
戻り値: 層の出力
戻り値の型: ndarray

3.1.19. Lstm

class renom.layers.function. lstm

Layer ⇐ Lstm

長・短期記憶(LSTM [12] )を実現します。LSTMはRNNに対して中間層の各ユニットをメモリユニットで置き換えた構造を持ちます。
以下の式で定義される順伝播計算を実行します。学習方法にはBPTT法を使用しています。 [6] 下付きの添え字jとiはそれぞれ、j番目のユニットに関する変数とi番目のユニットに関する変数を表しております。たとえば、 u_{j} は中間層のj番目のユニットへの入力値となります。
t : 時刻
u^{t} :この層への入力
w: 前の層からの入力に対する結合の重み
wf: 入力値から忘却ゲートの値を決めるユニットへの結合の重み
wi: 入力値から入力ゲートの値を決めるユニットへの結合の重み
wo: 入力値から出力ゲートの値を決めるユニットへの結合の重み
wfc: メモリセルから忘却ゲートの値を決めるユニットへの結合の重み
wic: メモリセルから入力ゲートの値を決めるユニットへの結合の重み
woc: メモリセルから出力ゲートの値を決めるユニットへの結合の重み
wr: 前の時刻からフィードバックされた入力に対する結合の重み
wfr: この層からの帰還入力から忘却ゲートの値を決めるユニットへの結合の重み
wir: この層からの帰還入力から入力ゲートの値を決めるユニットへの結合の重み
wor: この層からの帰還入力から出力ゲートの値を決めるユニットへの結合の重み
b: 前の層と前の時刻の中間層の入力に付与されるバイアス
bf: 忘却ゲートのバイアス
bi: 入力ゲートのバイアス
bo: 出力ゲートのバイアス
z^{t} : この層の出力
c^{t} : メモリセルの状態
\sigma(x)=sigmoid(x)=\frac{1}{1+e^{-x}}
h(x)= \tanh(x)
\begin{split}\begin{split} u_{j}^{t} &= \sum_{i}w_{ji}^{(t)}\cdot x_{i}^{t}+\sum_{j'}wr_{jj'}\cdot z_{j'}^{t-1}+b_{j}\\ \overline{i_{j}}^{t} &= \sum_{i}wi_{ji}^{(t)}\cdot x_{i}^{t}+\sum_{j'} wir_{jj'}\cdot z_{j'}^{t-1}+wic_{j}\cdot c_{j}^{t-1}+bi_{j}\\ i_j^{t} &=\sigma(\overline{i_{j}}^{t})\\ \overline{f_{j}}^{t} &=\sum_{i}wf_{ji}\cdot x_{i}^{t}+\sum_{j'} wfr_{jj'}\cdot z_{j'}^{t-1}+wfc_{j}\cdot c_{j}^{t-1}+bf_{j}\\ f_j^{t} &=\sigma(\overline{f_{j}}^{t})\\ c_{j}^{t} &=i_j^{t}\cdot z_{j}^{t}+f_j^{t}\cdot c_{j}^{t-1}\\ \overline{o_{j}}^{t} &=\sum_{i}wo_{ji}\cdot x_{i}^{t}+\sum_{j'} wor_{jj'}\cdot z_{j'}^{t-1}+woc_{j}\cdot c_{j}^{t-1}+bo_{j}\\ o_j^{t} &=\sigma(\overline{o_{j}}^{t})\\ z_{j}^{t} &=o_j^{t}\cdot h(c_{j}^{t}) \end{split}\end{split}
_init_ ( layer=None , unit=0 , weight_decay = None , initial_weight_scale = 1.0 , print_status = False )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • unit ( int ) – ユニット数を表します。
  • weight_decay ( float32 ) – 正則化の強さを制御するパラメータです。
  • initial_weight_scale ( float32 ) – 初期重みを与える正規分布の標準偏差です。
  • print_status ( bool ) – インスタンス化時に層の情報を出力します。

3.1.20. Dropout

class renom.layers.function. dropout

Layer ⇐ Dropout

ドロップアウトを実装します。
多層ネットワークのユニットを確率的に選択して学習を行います。
学習終了後、予測を行う際にはドロップアウトで無効化したユニットも使用して計算を行いますが、学習時に選択したユニットの割合をpとした場合、ユニットの出力は全てp倍となります。
_init_ ( layer=None , dropout_ratio=1.0 , print_status=False )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • dropout_ratio ( float32 ) – ユニット選出確率です。
  • print_status ( bool ) – インスタンス化時に層の情報を出力します。

3.1.21. Dense

class renom.layers.function. dense

Layer ⇐ Dense

全結合層を表すクラスです。initial_weightを指定しない場合、初期結合重みは、平均0、標準偏差1の正規分布に元づいて決定されます。バイアスについても同様に、initial_biasを指定しない場合、初期バイアスは0となります。
以下の式で定義される順伝播計算を実行します。
t : 時刻
x_{j}^{t} : 時刻tにおける次の層への出力
z_{j}^{t} : 時刻tにおける次の層への出力
w_{ji} : 前の層と、この層の結合重み
z_{j}=\sum_{i}w_{ji}\cdot x_{i}+b_j

また、weight_decayを指定した場合、重みパラメータの更新式は以下のようになります。 | lr: 学習係数 | N: サンプル数 | gw: 誤差の勾配 | wd : 重み減衰に関する正則化パラメータ

w_{ji}← w_{ji}−lr\cdot (gw_{ji}+wd\cdot w _{ji})
_init_ ( layer = None , unit = 0 , weight_decay = None , initial_weight_scale = 1.0 , print_status = False )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • unit ( int ) – ユニット数を表します。
  • weight_decay ( float32 ) – 正則化の強さを制御するパラメータです。
  • initial_weight_scale ( float32 ) – 初期重みを与える正規分布の標準偏差です。
  • initial_weight ( ndarray ) – 重みをinitial_weightで初期化します
  • initial_bias ( ndarray ) – バイアスをinitial_biasで初期化します
  • print_status ( bool ) – インスタンス化時に層の情報を出力します。

3.1.22. Split

class renom.layers.function. split

Layer ⇐ Split

一つの層の出力を複数の層に向けて分割します。

3.1.23. Concat

class renom.layers.function. concat

Layer ⇐ Concat

複数の層の出力をまとめて、一つの層の出力として扱うためのクラスです。

_init_ ( *layers )
パラメータ: layers ( tuple ) – 複数の層を引数としてとります。

3.1.24. Conv2d

class renom.layers.function. conv2d

Layer ⇐ Conv2d

2次元の畳み込みニューラルネットワークを定義します。 以下の式で定義される順伝播計算を実行します。

z_{ijm} : 層の出力
x_{ij} : 入力画像の画素値
w_{pq} : フィルタの画素値
l: 第l層
k: k番目の入力チャネル
m: m番目の入力チャネル
b_{m} : バイアス(各ユニット共通)
f: 活性化関数
H: フィルタのサイズ
K: チャネル数
z_{ijm}=\sum_{k=0}^{K-1}\sum_{p=0}^{H-1}\sum_{q=0}^{H-1}x_{i+p,j+q,k}\cdot w_{pqkm}+b_{m}

また、以下の2点はPool2dレイヤでも同様に扱います。

・パディングの幅の画素値は0としています(ゼロパディング)。
・出力される画像のサイズは以下の式で決定されます。
os : 出力画像のサイズ is : 入力画像のサイズ p : パディング k : カーネル s : ストライド
os =\lfloor(is+p×2−k)/s\rfloor+1

ただし、 \lfloor・\rfloor は小数点以下を切り捨てることを表します。

_init_ ( layer=None , channel=1 , filter_size=(3 , 3) , stride=(1 , 1) , padding =(0 , 0) , weight_decay=None , initial_weight_scale=1.0 , initial_weight =None , initial_bias=None , print_state=False )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • channel ( int ) – チャネル数を表します。
  • filter_size ( ndarray ) – フィルタのサイズです。
  • stride ( ndarray ) – フィルタ適用位置の間隔です。
  • padding ( ndarray ) – パディングの幅を表します。
  • weight_decay ( float32 ) – 正則化の強さを制御するパラメータです。
  • initial_weight_scale ( float32 ) – 初期重みを与える正規分布の標準偏差です。
  • initial_weight ( ndarray ) – 重みをinitial_weightで初期化します
  • initial_bias ( ndarray ) – バイアスをinitial_biasで初期化します
  • print_state ( bool ) – インスタンス化時に層の情報を出力します。

3.1.25. Sparse

class renom.layers.function. sparse

Layer ⇐ Sparse

スパース化したい層に対し実行することで、スパース正則化を行えます。 以下の式を最小化するようなw,βを決定します。

\tilde{E}(w) : 目的関数
\hat{p_{j}} : 中間層のユニット の平均活性度の推定値
p : 目標値となるパラメータ
\beta : との目標のバランスを変えるパラメータ
z_{j}^{n} : 層内のn番目のデータに対するj番目のユニットの出力
\begin{split}\begin{split} \tilde{E}(w)&\equiv E(w)+\beta\sum_{j=1}^{Dy}KL(p\parallel \hat{p_{j}})\\ \hat{p_{j}}&=\frac{1}{N}\sum_{n=1}^{N}z_{j}^{n}\\ KL(p\parallel\hat{p_{j}})&=plog(\frac{p}{\hat{p_j}})+(1-p)log(\frac{1-p}{1-\hat{p_j}})\\ \end{split}\end{split}

βの値を適度に調節することで、中間層のユニットが協力して個々の入力を表現するようになります。

_init_ ( layer = None , r = 0.05 , b = 0.5 , l = 0.9 )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • r ( float32 ) – 目標値となるパラメータです。
  • b ( float32 ) – ρとωの目標のバランスを変えるパラメータです。
  • l ( float32 ) – ユニットの平均重みです。

3.1.26. Pool2d

Pool2d renom.layers.function.pool2d

Layer ⇐ Pool2d

プーリング層を定義します。計算内容は以下の通りです。 ここでは最大プーリングのみを扱います。

p_{ij} : 画素(i,j)を中心とするH×H正方領域をとったときの画素の集合
x_{i+p,j+q,k} :
z_{ijk} :
param function opt_hook:
勾配降下アルゴリズム
z_{ijk}=\max_{(p,q)\in p_{ij}}x_{i+p,j+q,k}

パディングの画素値、出力画像のサイズはConv2dと同様に計算されます。

_init_ ( layer=None , channel=1 , filter_size=(3 , 3) , stride=(1 , 1) , padding =(0 , 0) , print_state=False )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • filter_size ( ndarray ) – フィルタのサイズです。
  • stride ( ndarray ) – フィルタ適用位置の間隔です。
  • padding ( ndarray ) – パディングの幅を表します。
  • print_state ( bool ) – インスタンス化時に層の情報を出力します。

3.1.27. Lrn

class renom.layers.function. lrn

Layer ⇐ Lrn

局所レスポンス正規化を定義します。計算内容は以下の通りです。

x_{ijl} : 第lチャネルの入力画像の座標( )における画素値
z_{ijl} : 出力される画素値
a,b,k : 正規化の為のパラメータです。
n : 平均を求める対象となるチャネル数
N : 全チャネル数
\begin{split}z_{ijl}&=\frac{x_{ijl}}{(k+a\ast \sum_{1=\max(0,j-\frac{n}{2})}^{\min(N-1,i+\frac{n}{2})}(x_{ijl})^{2})^{b}}\end{split}
_init_ ( layer=None , n=5 , k=2 , a=10^{-4} , b=0.75 , initial_weight=None , initial_bias=None )
パラメータ:
  • layer ( Layer ) – この層に値を渡す層を引数としてとります。
  • n ( int ) – 平均を求める対象となるチャネル数です。
  • k ( int ) – 正規化の為のパラメータです。
  • a ( float32 ) – 正規化の為のパラメータです。
  • b ( float32 ) – 正規化の為のパラメータです。
  • initial_weight ( ndarray ) – 重みをinitial_weightで初期化します
  • initial_bias ( ndarray ) – バイアスをinitial_biasで初期化します

3.1.28. Flatten

class renom.layers.function. flatten

Layer ⇐ Flatten

Conv2dやPool層の出力であるTensorを全結合層で扱うための行列に変換するためのレイヤです。

input_layer = Input((32, 32, 3))            # 入力層の定義 (縦32, 横32, チャネル3)
conv_layer = Conv2d(input_layer, channel = 16)       # 畳み込み層
activate = Relu(conv_layer)
flatten = Flatten(activate)
output_layer = Dense(flatten, 10)           # 全結合層
loss = Soft_Max_Cross_Entropy(output_layer) # 誤差関数

3.1.29. Input

class renom.layers.function. input

Layer ⇐ Input

ニューラルネットワークの入力となる層です。以下のコードサンプルのように使用します。

input_layer = Input(784)                    # 入力層の定義
middle_layer = Dense(input_layer, 100)      # 中間層の定義
activate = Sigmoid(middle_layer)            # 中間層の活性化関数
output_layer = Dense(activate, 10)          # 出力層
loss = Soft_Max_Cross_Entropy(output_layer) # 誤差関数
_init_ ( unit = 0 )
パラメータ: unit ( int , tuple ) – この層に値を渡す層を引数としてとります。

3.1.30. Soft_Max_Cross_Entropy

class renom.layers.loss. soft_max_cross_entropy

Layer ⇐ Soft_max_Cross_Entropy

入力値にソフトマックス活性化関数を使用し、さらに誤差関数として交差エントロピーを定義する層です。

E: 誤差関数
J: 次元数
N: 訓練データ数
d_{j}^{n} : n番目のデータに対する目標出力
x_{j}^{n} : この層のj番目のユニットへの入力
y_{j}^{n} : ソフトマックス関数のj番目のユニットの出力
\begin{split}\begin{split} y_{i}^{n} &=\frac{e^{x_{j}^{n}}}{\sum_{j}e^{x_{j}^{n}}}\\ E &=-\frac{1}{N}\sum_{n=1}^{N}\sum_{j=1}^{J}d_{nj}\cdot log(y_{j}^{n}) \end{split}\end{split}

3.1.31. Sigmoid_Cross_Entropy

class renom.layers.loss. sigmoid_cross_entropy

Layer ⇐ Sigmoid_Cross_Entropy

シグモイド関数から導かれる誤差関数を定義します。

E: 誤差関数
N: 訓練データ数
d_{j}^{n} :目標出力
x_{j}^{n} :入力
y_{j}^{n} :出力
\begin{split}\begin{split} y_{j}^{n} &=\frac{1}{1+e^{-x_{j}^{n}}}\\ E &=-\frac{1}{N}\sum_{n=1}^{N}\sum_{j=1}^{J}[d_{n}\cdot log(y_j^{n})+(1-d_{n})\cdot log(1-y_{j}^{n})]\\ \end{split}\end{split}

3.1.32. Mean_Squared_Error

class renom.layers.loss. mean_squared_error

Layer ⇐ Mean_Squared_Error

誤差関数として二乗誤差を定義します。

E: 誤差関数
J: ユニット数
y_{j}^{n} : 前の層の出力
d_{j}^{n} : 目標出力
E(w)=\frac{1}{2N}\sum_{n=1}^{N}\sum_{j=1}^{J}(y_{j}^{n}-d_{j}^{n})^{2}

3.2. ユーティリティ

ユーティリティ関数はrenom.utils.normallizationに定義されており、データの標準化、 白色化を行う関数が含まれております。

3.2.1. normalize

renom.layers.utils. normalization ( )

データを正規化します。標準化は以下の式で与えられます。

x_{i} : データ
\mu_{i} : データの平均値
\sigma_{i} : データの標準偏差 (iは入力データの次元)
z_{i} =\frac{x_{i}-\mu_{i}}{\sigma_{i}}
データの平均を0、標準偏差を1とする処理になります。
また、訓練データの標準偏差が極端に小さくなる時、εを使用します。
\begin{split}\sigma_{i} =\max(\sigma^{'},\varepsilon) &\text{ where } \varepsilon=10^{-6}\end{split}
パラメータ: data ( ndarray ) – 標準化を行う対象となるデータです。
戻り値: 標準化したデータ
戻り値の型: ndarray
pca_whitening ( )

PCA白色化を行います。白色化処理後の訓練データは、各成分間の相関がなくなります。 {x_{n}} を訓練データ、 {u_{n}} を出力値とすると、白色化は以下の式で与えられます。

\begin{split} u_{n}=p_{x_{n}}(n=1,...,N) \end{split}

以下、白色化を行う変換行列Pを求めます。変換後の {u_{n}} の共分散行列

\begin{split} \phi_{u}=\frac{1}{N}\sum_{n=1}^{N}u_{n}u_{n}^{T}=\frac{1}{N}\frac{U}{U^{T}} \end{split}

が対角行列になるようにPを定めます。対角行列 \phi_{u} を単位行列とすると、Pが満たすべき式は、U = PXを代入すると、

\begin{split} p^{T}p=\phi_{x}^{-1} \end{split}

\phi_{x} の固有ベクトルを列ベクトルに持つ行列をEとし、 \phi_{x} の固有値を対角成分に持つ対角行列をDとすると、

\begin{split} \phi_{x}=EDE^{T} \end{split}

が対角行列になるようにPを定めます。対角行列 \phi_{u} を単位行列とすると、Pが満たすべき式は、U = PXを代入すると、

\begin{split} p^{T}p=\phi_{x}^{-1} \end{split}

\phi_{x} の固有ベクトルを列ベクトルに持つ行列をEとし、 \phi_{x} の固有値を対角成分に持つ対角行列をDとすると、

\begin{split} \phi_{x}=EDE^{T} \end{split}

Eは直行行列であることから、 \phi_{x}^{-1}=EDE^{-1}E^{T} と書けます。 よって、求めるPは

\begin{split} P=QD^{-\frac{1}{2}}E^{T} \end{split}

となります( D^{-\frac{1}{2}} は の対角成分を -\frac{1}{2} 乗した対角行列、QはPと同サイズの任意の直行行列)。また、Dの成分が極端に小さいとき、εを成分とします。 d'_{j} を行列Dの i 番目の成分としています。

\begin{split}\begin{split} d_{i}=\max(d'_{j},\varepsilon)&\text{ where }\varepsilon=10^{-6} \end{split}\end{split}
パラメータ: data ( ndarray ) – 訓練データを入力します。
戻り値: PCA白色化した結果
戻り値の型: ndarray
zpc_whitening ( )

上記の白色化において行列 を対称行列に限定した、ZPC白色化を行います。

P=QD^{-\frac{1}{2}}E^{T}
パラメータ: data ( ndarray ) – 訓練データを入力します。
戻り値: ZPC白色化した結果を返します。
戻り値の型: ndarray

3.3. 前処理方法

ReNomにデータを入力する際の前処理方法について説明します。ReNomでは、データの正規化、 白色化を行う関数が定義されています。これらの関数は次のようにして使用します。下記のコードは、正規化例です。データの並び方は、概要の「データ表現方法」を参照してください。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import numpy as np
from renom.utils.normalization import normalize

data = np.random.rand(3,3)
print(data)
# [[ 1.61256276e-01 1.35789684e-01 1.04241293e-04]
#  [ 2.64651162e-01 8.68438609e-01 7.58577049e-01]
#  [ 4.75262151e-01 7.80200271e-01 2.64102689e-02]]

X = normalize(data)
print(X)
# [[-1.06485614 -1.40558326 -0.74419516]
#  [-0.27352544 0.83789073 1.41355337]
#  [ 1.33838158 0.56769253 -0.66935821]]

3.4. 学習結果が収束しなかったときのチェックポイント

計算途中で誤差が発散してしまった場合

  • 各層のユニット数が数千個となっている場合、次のレイヤへの入力値が大きくなり、計算途中で値がオーバフローすることがあります。その場合は、初期重みを小さくするか、学習率を下げる、重み減衰を行うなどの方法を試みることで、オーバフローを避けられる可能性があります。
[7] Djork-Arne Clevert, Thomas Unterthiner & Sepp Hochreiter (2016)Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs)arXiv:1511.07289v5 [cs.LG] 22 Feb 2016
[8] John Duchi, Elad Hazan, Yoram Singer (2011)Adaptive Subgradient Methods for Online Learning and Stochastic Optimization Journal of Machine Learning Research 12 (2011) 2121-2159
[9] Diederik Kingma, Jimmy Ba (2015) A Method for Stochastic Optimization arXiv:1412.6980v8 [cs.LG] 23 Jul 2015
[10] Matthew D. Zeiler (2012) An adaptibe learning rate method arXiv:1212.5701v1 [cs.LG] 22 Dec 2012
[11] Tieleman, T. and Hinton, G. (2012) Lecture 6.5 RMSProp, COURSERA Neural Networks for Machine Learning. Technical report, 2012
[12] Felix Gers(2001) Long Short-Term Memory in Recurrent Neural Networks