パラメトリック関数
NNabla では、最適化可能なパラメータを持つ複数の関数を組み合わせることでで学習可能なモデルを作成します。このような関数をパラメトリック関数といいます。パラメトリック関数は、 nnabla.parametric_functions にて提供されています。
- また、
Python API Tutorial も併せてご参照ください。
パラメータを管理するためのAPI
全ての パラメトリック関数リスト によって登録されるパラメータは、このセクションにリストアップされているAPI を使って管理することができます。
- nnabla.parameter.parameter_scope(name, scope=None)[ソース]
nnabla.parametric_functionsにリストされたパラメトリック関数によって登録されるパラメータをグループ化します。- パラメータ:
name (str) -- パラメータスコープ名。
scope (OrderedDict, optional) -- 現在のパラメータスコープをローカルディクショナリとして指定する。デフォルト値は
Noneです。この場合、グローバルに保持されている現在のパラメータスコープが使用されます。
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.functions as F with nn.parameter_scope('conv1'): conv_out1 = PF.convolution(x, 32, (5, 5)) bn_out1 = PF.batch_normalization(conv_out1) act_out1 = F.relu(bn_out1) with nn.parameter_scope('conv2'): conv_out2 = PF.convolution(act_out1, 64, (3, 3)) bn_out2 = PF.batch_normalization(conv_out2) act_out2 = F.relu(bn_out2)
The with statement文のブロックを入れ子に(ネスト)することで、パラメータスコープを入れ子に(ネスト)することができます。また、これはパラメータ名に “/” を使うことでも可能となります。例：
with nn.parameter_scope('network1'): with nn.parameter_scope('conv1'): conv_out1 = PF.convolution(x, 32, (5, 5)) bn_out1 = PF.batch_normalization(conv_out1) act_out1 = F.relu(bn_out1) with nn.parameter_scope('conv2'): conv_out2 = PF.convolution(act_out1, 64, (3, 3)) bn_out2 = PF.batch_normalization(conv_out2) act_out2 = F.relu(bn_out2)
以下と同等です。
with nn.parameter_scope('network1/conv1'): conv_out1 = PF.convolution(x, 32, (5, 5)) bn_out1 = PF.batch_normalization(conv_out1) act_out1 = F.relu(bn_out1) with nn.parameter_scope('network1/conv2'): conv_out2 = PF.convolution(act_out1, 64, (3, 3)) bn_out2 = PF.batch_normalization(conv_out2) act_out2 = F.relu(bn_out2)
- nnabla.parameter.get_parameters(params=None, path='', grad_only=True)[ソース]
現在のパラメータスコープにおけるパラメータ変数を取得します。
- nnabla.parameter.save_parameters(path, params=None, extension=None)[ソース]
すべてのパラメータを特定のフォーマットでファイルに保存します。
現在、hdf5 と protobuf のフォーマットがサポートされています。
- nnabla.parameter.load_parameters(path, proto=None, needs_proto=False, extension='.nntxt')[ソース]
特定のフォーマットのファイルからパラメータを読み込みます。
- パラメータ:
path -- パスまたはファイルオブジェクト
- nnabla.parameter.get_parameter_or_create(name, shape=None, initializer=None, need_grad=True, as_need_grad=None)[ソース]
現在のパラメータスコープに存在する、指定された名前のパラメータ変数を返します。
指定された名前の変数が存在しない場合には、新しい変数を作成し、現在のパラメータスコープにその名前で登録してから、パラメータ変数を返します。
- パラメータ:
name (str) -- 現在のスコープにおける名前。すでに存在する場合、名前はパラメータマネージャーから照会されます。
shape (
tupleofint) -- 作成されるパラメータの形状。指定されたパラメータの形状は、この形状と一致する必要があります。デフォルトは None で、イニシャライザーがnumpy.ndarrayとして指定されている場合にのみ有効です。initializer (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- パラメータに適用される初期化関数。numpy.ndarrayを指定して、numpy 配列データからパラメータを初期化することもできます。need_grad (bool) -- 指定された
need_gradフラグでパラメータを登録します。デフォルトは True です。フラグが以前に指定されたものと異なる場合、フラグは上書きされますが、パラメータの値は保持されます。as_need_grad (bool) -- 指定された
need_gradフラグでパラメータ変数を取得します。これは、指定された名前を持つ、登録済みのパラメータ変数のフラグを上書きしないことに注意してください。代わりに、指定されたフラグが以前に登録されたneed_gradフラグと一致しない場合、同じ配列の内容を参照する新しい変数を返しますが、その際need_grad=as_need_gradを使用します。
注釈
It returns a Variable which is unlinked from the registered one in the current parameter scope (using
nnabla.Variable.get_unlinked_variable()). That means changing aneed_gradattribute doesn't affect the variable existing in the current parameter scope.
パラメトリック関数リスト
以下にリストアップされているパラメトリック関数は、 nnabla.parametric_functions にて提供されています。 関数 にリストされている関数と同様に、最初の引数には Variable 、次にそれぞれのパラメトリック関数固有のオプションを取ります。さらに、パラメータ変数 ( Variable ) をパラメータスコープに登録します。
The parameter variables are registered with need_grad properties specific
to a parametric function. The variables with need_grad=False flag will not
be updated by gradient descent. Hence, backward computation is not executed for
those variables. False is usually specified when the parameters are updated
during forward pass and/or backward pass, e.g., batch normalization.
すべてのパラメトリック関数は、オプション引数 fix_parameters=False を取ります。 True を渡すと、関連したパラメータ変数は登録されている変数のプロパティに関係なく、プロパティ need_grad=False で計算グラフ (computation graph) に繋がり、それらの変数に対して backward 勾配計算は行われません。これは、評価目的で計算グラフを構築したり、グラフ中の一部のパラメータを固定したりする際に便利です。
以下にリストアップされているパラメトリック関数はすべて、下記のデコレータを使ってデコレートされています。
- nnabla.parametric_functions.parametric_function_api(scope_name=None, param_desc=None)[ソース]
パラメトリック関数のデコレータ
デコレートされた関数は、常にパラメータスコープ
scope_nameのもとで呼ばれます。また、最後の引数としてname(str, デフォルトはNone) が追加されます。nameが指定されると、スコープscope_nameはスコープnameの下にネストされます。この機能に利用することで、ソースコードの行数を削減することができます。どのパラメトリック関数でもこのデコレータでデコレートする必要があります。
登録されている変数を照会および操作する方法については、 パラメータを管理するためのAPI を参照してください。
以下は、パラメトリック関数のリストです。
- nnabla.parametric_functions.affine(inp, n_outmaps, base_axis=1, w_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, apply_w=None, apply_b=None, name=None)[ソース]
全結合層ともいわれる、affine 層。以下の計算を行います。
\[{\mathbf y} = {\mathbf A} {\mathbf x} + {\mathbf b}.\]ここでは、 \({\mathbf x}, {\mathbf y}\) はそれぞれ入力、出力、 \({\mathbf A}, {\mathbf b}\) は定数です。
- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列となるように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
apply_w (function) -- 重みに適用されるラムダ、関数、または呼び出し可能なオブジェクト。
apply_b (function) -- バイアスに適用されるラムダ、関数、または呼び出し可能なオブジェクト。
- 戻り値:
\((B + 1)\)-D 配列。 (\(M_0 \times \ldots \times M_{B-1} \times L\))
- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"affine"に登録されます。W (
need_grad=True) : 重み行列 (形状:(inmaps, outmaps))b (
need_grad=True) : バイアスベクター (形状:(outputs,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = affine(<args>)
- nnabla.parametric_functions.convolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, channel_last=False, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, apply_w=None, apply_b=None, name=None)[ソース]
バイアス項を含んだ N-D Convolution
Dilated Convolution (別名 Atrous Convolution) については、以下をご参照ください。
Chen et al., DeepLab: Semantic Image Segmentation with Deep Convolutional Nets, Atrous Convolution, and Fully Connected CRFs. https://arxiv.org/abs/1606.00915
Yu et al., Multi-Scale Context Aggregation by Dilated Convolutions. https://arxiv.org/abs/1511.07122
注釈
Convolution は、計算負荷の大きい演算となるため、
cudnnバックエンドで実行することを推奨します。その際、NNabla は CuDNN library の関数を使って、 与えられたconvolution パラメータセットに対して最速のアルゴリズムを決定し、キャッシュします。それにより、メモリをさらに消費し、GPU のメモリサイズが足りなくなる問題を引き起こす可能性があります。そのような場合は、環境変数NNABLA_CUDNN_WORKSPACE_LIMITにバイト数を指定することで、所定のワークスペースのメモリ制限に収まるように、アルゴリズムの選択を制限することができます。場合によっては、自動検索を決定的な（再現性のある）結果を生成するアルゴリズムに制限した方がよいケースがあります。その場合には、環境変数NNABLA_CUDNN_DETERMINISTICをゼロ以外の値に設定してください。- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
channel_last (bool) -- True の場合、最後の次元はチャネル次元になり、いわゆるNHWC 順になります。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
apply_w (function) -- 重みに適用されるラムダ、関数、または呼び出し可能なオブジェクト。
apply_b (function) -- バイアスに適用されるラムダ、関数、または呼び出し可能なオブジェクト。
- 戻り値:
N-D 配列。出力形状については、
convolutionを参照してください。- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"conv"に登録されます。W (
need_grad=True) : フィルターの重み (形状:(outmaps, inmaps // group, *kernel))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = convolution(<args>)
- nnabla.parametric_functions.depthwise_convolution(inp, kernel, pad=None, stride=None, dilation=None, multiplier=1, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
バイアス項を使った N-D Depthwise Convolution
参照 :
Chollet: Chollet, Francois. "Xception: Deep Learning with Depthwise Separable Convolutions. https://arxiv.org/abs/1610.02357
- パラメータ:
inp (Variable) -- N-D 配列
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。multiplier (
int) -- 入力特徴マップごとの出力特徴マップの数。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
N-D 配列。出力形状については、
depthwise_convolutionを参照してください。- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"depthwise_conv"に登録されます。W (
need_grad=True) : フィルターの重み (形状:(inmaps * multiplier, *kernel))b (
need_grad=True) : バイアスベクター (形状:(inmaps * multiplier,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = depthwise_convolution(<args>)
- nnabla.parametric_functions.deconvolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, channel_last=False, output_padding=None, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, apply_w=None, apply_b=None, name=None)[ソース]
Deconvolution 層
- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- deconvolution カーネルの数（出力チャネル数と同じ）。例えば、入力に対して、16 種類のフィルターによるdeconvolution を適用するには、16 を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の2次元カーネルによる deconvolution を適用するには、( 3, 5 )を指定します。group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
apply_w (function) -- 重みに適用されるラムダ、関数、または呼び出し可能なオブジェクト。
apply_b (function) -- バイアスに適用されるラムダ、関数、または呼び出し可能なオブジェクト。
- 戻り値:
N-D 配列。出力形状については、
deconvolutionを参照してください。- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"deconv"に登録されます。W (
need_grad=True) : フィルターの重み (形状:(inmaps, outmaps // group, *kernel))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = deconvolution(<args>)
- nnabla.parametric_functions.depthwise_deconvolution(inp, kernel, pad=None, stride=None, dilation=None, divisor=1, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
Depthwise deconvolution は、1 次元および 2 次元の入力データに対して depthwise convolusion の転置を計算します。
- パラメータ:
inp (Variable) -- N-D 配列
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。divisor (
int) -- 出力フィーチャマップごとの入力フィーチャマップの数。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
N-D 配列。出力形状については、
depthwise_deconvolutionを参照してください。- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"depthwise_deconv"に登録されます。W (
need_grad=True) : フィルターの重み (形状:(inmaps,) + kernel)b (
need_grad=True) : バイアスベクター (形状:(inmaps / divisor,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = depthwise_deconvolution(<args>)
- nnabla.parametric_functions.deformable_convolution(inp, outmaps, kernel, offset, mask=None, pad=None, stride=None, dilation=None, group=1, deformable_group=1, channel_last=False, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, apply_w=None, apply_b=None, name=None)[ソース]
2D Deformable Convolution with a bias term. If use mask, this function is Deformable Convolution v2.
Dai et al., Deformable Convolutional Networks. https://arxiv.org/abs/1703.06211
Zhu et al., Deformable ConvNets v2: More Deformable, Better Results. https://arxiv.org/abs/1811.11168
- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。offset (Variable) -- Offsets for deformable convolutions. Shape is fixed to \((N, deformable{\_}group \times 2 \times Kh \times Kw, H, W)\). Offsets must be calculated externally through a separate convolution layer.
mask (Variable) -- Normalized mask for deformable convolutions v2. Shape is fixed to \((N, deformable{\_}group \times Kh \times Kw, H, W)\). Masks must be calculated externally together with the offsets through a separate convolution layer.
group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
deformable_group (int) -- Number of deformable groups of channels. This makes connections across channels more sparse by grouping connections along map direction.
channel_last (bool) -- True の場合、最後の次元はチャネル次元になり、いわゆるNHWC 順になります。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
apply_w (function) -- 重みに適用されるラムダ、関数、または呼び出し可能なオブジェクト。
apply_b (function) -- バイアスに適用されるラムダ、関数、または呼び出し可能なオブジェクト。
- 戻り値:
N-D 配列。出力形状については、
convolutionを参照してください。- 戻り値の型:
- 登録されるパラメータ
The following variables are registered in a parameter scope
"deformable_conv";W (
need_grad=True) : フィルターの重み (形状:(outmaps, inmaps // group, *kernel))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = deformable_convolution(<args>)
- nnabla.parametric_functions.batch_normalization(inp, axes=[1], decay_rate=0.9, eps=1e-05, batch_stat=True, output_stat=False, fix_parameters=False, param_init=None, no_scale=False, no_bias=False, name=None)[ソース]
Batch normalization 層
\[\begin{split}\begin{array}{lcl} \mu &=& \frac{1}{M} \sum x_i\\ \sigma^2 &=& \frac{1}{M} \sum \left(x_i - \mu\right)^2\\ \hat{x}_i &=& \frac{x_i - \mu}{\sqrt{\sigma^2 + \epsilon }}\\ y_i &= & \hat{x}_i \gamma + \beta. \end{array}\end{split}\]ここでは、 \(x_i, y_i\) は入力とします。テスト時には、学習中に計算された移動平均を使って算出された平均 (mean) と分散 (variance) が使われます。
- パラメータ:
inp (Variable) -- 入力の N-D 配列。
axes (
tupleofint) --axesの各要素の平均と分散は、残りの axes の要素を使用して計算されます。例えば、入力が 4 次元で、axesが[1]の場合、バッチ平均はnp.mean(inp.d, axis=(0, 2, 3), keepdims=True)として計算されます ( numpy 式を例として使用 )。decay_rate (float) -- 移動平均と分散の減衰率。
eps (float) -- std によるゼロ除算を回避する小さな値。
batch_stat (bool) -- 移動統計量ではなく、ミニバッチ統計量を使用します。
output_stat (bool) -- バッチ平均と分散を出力します。
param_init (dict) -- パラメータイニシャライザーは dict で設定できます。dict のキーは
'beta'、'gamma'、'mean'または'var'である必要があります。dict の値は、Initializerまたは numpy.ndarraynumpy.ndarrayである必要があります。例{'beta': ConstantInitializer(0), 'gamma': np.ones(gamma_shape) * 2}。
- 戻り値:
N-D 配列
- 戻り値の型:
参照
Ioffe and Szegedy, Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. https://arxiv.org/abs/1502.03167
パラメータの形状は入力データと同じ次元数で、各軸のサイズは、
axesに指定された軸については入力と同じ大きさであり、残りは1となります。例えば、入力が 4 次元で、axes=[1]である場合、パラメータ形状は、param_shape = np.mean(inp.d, axis=(0, 2, 3), keepdims=True).shape(例として、numpy 表記を使用) となります。- 登録されるパラメータ
以下の変数は、パラメータスコープ
"bn"に登録されます。beta (
need_grad=True) : 学習可能な \(\beta\). (形状:<上記参照>)gamma (
need_grad=True) : 学習可能なスケーリングファクター \(\gamma\). (形状:<上記参照>)mean (
need_grad=False) : バッチ平均の移動平均 (形状:<上記参照>)var (
need_grad=False) : バッチ分散の移動平均 (形状:<上記参照>)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = batch_normalization(<args>)
- nnabla.parametric_functions.fused_batch_normalization(inp, z=None, axes=[1], decay_rate=0.9, eps=1e-05, batch_stat=True, nonlinearity='relu', output_stat=False, fix_parameters=False, param_init=None, no_scale=False, no_bias=False, name=None)[ソース]
Batch Normalizationの直後に続く残差入力とのadd2演算と非線形活性化演算の実行を含んだ Batch normalization 層。
- パラメータ:
inp (Variable) -- 入力の N-D 配列。
z (Variable, optional) -- 残差の入力。 None を指定すると、BN 操作の直後に activation 関数が実行されます。
axes (
tupleofint) --axesの各要素の平均と分散は、残りの axes の要素を使用して計算されます。例えば、入力が 4 次元で、axesが[1]の場合、バッチ平均はnp.mean(inp.d, axis=(0, 2, 3), keepdims=True)として計算されます ( numpy 式を例として使用 )。decay_rate (float) -- 移動平均と分散の減衰率。
eps (float) -- std によるゼロ除算を回避する小さな値。
batch_stat (bool) -- 移動統計量ではなく、ミニバッチ統計量を使用します。
nonlinearity (string) -- activation 関数。デフォルトは 'relu' です。
output_stat (bool) -- バッチ平均と分散を出力します。
- 戻り値:
N-D 配列
- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"bn"に登録されます。beta (
need_grad=True) : 学習可能な \(\beta\). (形状:<上記参照>)gamma (
need_grad=True) : 学習可能なスケーリングファクター \(\gamma\). (形状:<上記参照>)mean (
need_grad=False) : バッチ平均の移動平均 (形状:<上記参照>)var (
need_grad=False) : バッチ分散の移動平均 (形状:<上記参照>)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = fused_batch_normalization(<args>)
- nnabla.parametric_functions.sync_batch_normalization(inp, comm, group='world', axes=[1], decay_rate=0.9, eps=1e-05, batch_stat=True, output_stat=False, fix_parameters=False, param_init=None, no_scale=False, no_bias=False, name=None)[ソース]
Synchronized batch normalization 層
タスク (例: semantic segmentation ) によっては、バッチサイズが小さすぎて、BatchNormalization 層がうまく動かない場合があります。SyncBatchNorlization 層は、バッチ統計情報（平均と分散）を複数のプロセス間で同期することでこのような問題を解決します。
\[\begin{split}\begin{array}{lcl} \mu &=& \frac{1}{M} \sum x_i\\ \sigma^2 &=& \frac{1}{M} \left(\sum x_i - \mu\right)^2\\ \hat{x}_i &=& \frac{x_i - \mu}{\sqrt{\sigma^2 + \epsilon }}\\ y_i &= & \hat{x}_i \gamma + \beta. \end{array}\end{split}\]ここでは、 \(x_i, y_i\) は入力とします。
- パラメータ:
inp (Variable) -- 入力の N-D 配列。
comm (Communicator) -- communicator
group (string) -- communicator グループの名前
axes (
tupleofint) --axesの各要素の平均と分散は、残りの axes の要素を使用して計算されます。例えば、入力が 4 次元で、axesが[1]の場合、バッチ平均はnp.mean(inp.d, axis=(0, 2, 3), keepdims=True)として計算されます ( numpy 式を例として使用 )。decay_rate (float) -- 移動平均と分散の減衰率。
eps (float) -- std によるゼロ除算を回避する小さな値。
batch_stat (bool) -- 移動統計量ではなく、ミニバッチ統計量を使用します。
output_stat (bool) -- バッチ平均と分散を出力します。
param_init (dict) -- パラメータイニシャライザーは dict で設定できます。dict のキーは
'beta'、'gamma'、'mean'または'var'である必要があります。dict の値は、Initializerまたは numpy.ndarraynumpy.ndarrayである必要があります。例{'beta': ConstantInitializer(0), 'gamma': np.ones(gamma_shape) * 2}。
- 戻り値:
N-D 配列
- 戻り値の型:
参照
Ioffe and Szegedy, Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift, https://arxiv.org/abs/1502.03167
Hang Zhang, Kristin Dana, Jianping Shi, Zhongyue Zhang, Xiaogang Wang, Ambrish Tyagi, Amit Agrawal, Context Encoding for Semantic Segmentation, https://arxiv.org/abs/1803.08904
Implementing Synchronized Multi-GPU Batch Normalization https://hangzhang.org/PyTorch-Encoding/notes/syncbn.html
パラメータの形状は入力データと同じ次元数で、各軸のサイズは、
axesに指定された軸については入力と同じ大きさであり、残りは1となります。例えば、入力が 4 次元で、axes=[1]である場合、パラメータ形状は、param_shape = np.mean(inp.d, axis=(0, 2, 3), keepdims=True).shape(例として、numpy 表記を使用) となります。- 登録されるパラメータ
以下の変数は、パラメータスコープ
"bn"に登録されます。beta (
need_grad=True) : 学習可能な \(\beta\). (形状:<上記参照>)gamma (
need_grad=True) : 学習可能なスケーリングファクター \(\gamma\). (形状:<上記参照>)mean (
need_grad=False) : バッチ平均の移動平均 (形状:<上記参照>)var (
need_grad=False) : バッチ分散の移動平均 (形状:<上記参照>)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = sync_batch_normalization(<args>)
- nnabla.parametric_functions.mean_subtraction(inp, base_axis=1, update_running_mean=True, fix_parameters=False, name=None)[ソース]
Mean subtraction 層
入力配列の要素の平均値を減算し、平均を \(0\) に正規化します。この関数を使った配列の前処理は、画像分類などの様々なタスクにおいて精度を向上させる効果があります。
学習時は、この関数は以下のように定義されます。
\[\begin{split}\begin{array}{lcl} \mu &=& \frac{1}{M} \sum x_i \\ y_i &=& x_i - \mu \end{array}\end{split}\]テスト時には、学習中に計算した移動平均の値を上式の平均として利用します。
注釈
backward は、最新のミニバッチのみを考慮した近似微分を行います。
- パラメータ:
- 戻り値:
N-D 配列
- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"mean_subtraction"に登録されます。mean (
need_grad=False) : 移動平均 (形状:inp.shape[base_axis:])t (
need_grad=False) : forward パスを使ったミニバッチカウンター (形状:(1,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = mean_subtraction(<args>)
- nnabla.parametric_functions.layer_normalization(inp, batch_axis=0, eps=1e-05, output_stat=False, fix_parameters=False, param_init=None, no_scale=False, no_bias=False, name=None)[ソース]
入力変数に Layer Normalization を適用します。Layer Normalizationは以下のように定義されます。
\[\begin{split}\begin{eqnarray} \mu^l &=& \frac{1}{H} \sum_{i=1}^{H} x_i^l \\ \sigma^l &=& \sqrt{\frac{1}{H} \sum_{i=1}^{H} \left(x_i^l - \mu^l\right)^2} \\ y &=& \frac{x - \mu^l}{\sigma^l + \epsilon} \gamma + \beta \end{eqnarray}\end{split}\]ここでは、 \(x\) と \(y\) は入力と出力変数、 \(\mu^l\) と \(\sigma^l\) はバッチ軸に沿った層ごとの平均値と標準値、 \(\alpha\) と \(\beta\) は学習可能なパラメータです。
注釈
Unlike other normalization, which applies scalar scale and bias for each entire channel/plane, Layer Normalization applies per-element scale and bias.
参照
- パラメータ:
inp (Variable) -- 入力変数。
batch_axis (int or repeated int) -- 平均と分散を計算する軸。
eps (float) -- std によるゼロ除算を回避する小さな値。
param_init (dict) -- パラメータイニシャライザーは dict で設定できます。 dictのキーは
'gamma'、'beta'である必要があります。dict の値は、Initializerまたはnumpy.ndarrayである必要があります。例{'gamma': np.ones(...) * 2, 'beta': ConstantInitializer(0)}。
- 戻り値:
Normalized output variable. *
Variable: Mean (ifoutput_stat=True). *Variable: Std (ifoutput_stat=True)- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"layer_normalization"に登録されます。beta (
need_grad=True) : 学習可能な \(\beta\). (形状:<上記参照>)gamma (
need_grad=True) : 学習可能なスケーリングファクター \(\gamma\). (形状:<上記参照>)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = layer_normalization(<args>)
- nnabla.parametric_functions.instance_normalization(inp, channel_axis=1, batch_axis=0, eps=1e-05, output_stat=False, fix_parameters=False, param_init=None, no_scale=False, no_bias=False, name=None)[ソース]
入力変数に Instance Normalization を適用します。Instance Normalizaionは以下のように定義されます。
\[\begin{split}\begin{eqnarray} \mu^i &=& \frac{1}{H} \sum_{i=1}^{H} x_i^i \\ \sigma^i &=& \sqrt{\frac{1}{H} \sum_{i=1}^{H} \left(x_i^i - \mu^i\right)^2} \\ y &=& \frac{x - \mu^i}{\sigma^ + \epsilon} \gamma + \beta \end{eqnarray}\end{split}\]ここでは、 \(x\) と \(y\) は入力と出力変数、 \(\mu^i\) と \(\sigma^i\) はバッチとチャネルごとに個別に計算される平均値と標準偏差、 \(\gamma\) と \(\beta\) は適用ゲインとバイアスとします。
例えば、入力の形状が [ B, C, H, W ] ( = channel_axis=1, batch_axis=0 ) の場合、 計算される平均値と標準値の形状は [ B, C, 1, 1 ] です。
参照
- パラメータ:
inp (Variable) -- 入力変数。
channel_axis (int or repeated int) -- チャンネル軸。
batch_axis (int or repeated int) -- バッチ軸。
eps (float) -- std によるゼロ除算を回避する小さな値。
param_init (dict) -- パラメータイニシャライザーは dict で設定できます。 dictのキーは
'gamma'、'beta'である必要があります。dict の値は、Initializerまたはnumpy.ndarrayである必要があります。例{'gamma': np.ones(...) * 2, 'beta': ConstantInitializer(0)}。Returns --
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"instance_normalization"に登録されます。beta (
need_grad=True) : 学習可能な \(\beta\). (形状:<上記参照>)gamma (
need_grad=True) : 学習可能なスケーリングファクター \(\gamma\). (形状:<上記参照>)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = instance_normalization(<args>)
- nnabla.parametric_functions.group_normalization(inp, num_groups, channel_axis=1, batch_axis=0, eps=1e-05, output_stat=False, fix_parameters=False, param_init=None, no_scale=False, no_bias=False, name=None)[ソース]
入力変数に Group Normalization を適用します。Group Normalizationは以下のように定義されます。
\[\begin{split}\begin{eqnarray} \mu^g &=& \frac{1}{H} \sum_{i=1}^{H} x_i^g \\ \sigma^g &=& \sqrt{\frac{1}{H} \sum_{i=1}^{H} \left(x_i^g - \mu^g\right)^2} \\ y &=& \frac{x - \mu^g}{\sigma^g + \epsilon} \gamma + \beta \end{eqnarray}\end{split}\]ここでは、 \(x\) と \(y\) は入力と出力変数、 \(\mu^g\) と \(\sigma^g\) は グループごとの平均と標準偏差で、各グループのチェンネル数は
num_channels / num_groupsです。 \(\gamma\) と \(\beta\) は適応ゲインとバイアスです。channel_axisによって指定された入力チャネルは、num_groupsグループに分けられ、グループごとに平均と標準偏差が計算されます。例えば、入力の形状が [ B, C, H, W ] (= channel_axis=1, batch_axis=0) の場合、入力変数は、まず [ B, num_groups, C / num_groups, H, W ] に変形され、形状が [ B, num_groups, C / num_groups, 1, 1 ] の平均値と標準値によって標準化されます。出力変数は元々の入力の形状 ( 上述の例の場合は [ B, C, H, W ])に再度変形されてから出力されます。参照
- パラメータ:
inp (Variable) -- 入力変数。
num_groups (int) -- グループ数。 'x' のチャンネル dim は
num_groupsの整数倍である必要があります。channel_axis (int) -- チャンネル軸。
batch_axis (int or repeated int) -- 平均と分散を計算する軸。
eps (float) -- std によるゼロ除算を回避する小さな値。
output_stat (bool) -- True の場合、平均と分散のバッチの統計。
param_init (dict) -- パラメータイニシャライザーは dict で設定できます。 dictのキーは
'gamma'、'beta'である必要があります。dict の値は、Initializerまたはnumpy.ndarrayである必要があります。例{'gamma': np.ones(...) * 2, 'beta': ConstantInitializer(0)}。
- 戻り値:
Normalized output variable. *
Variable: Mean (ifoutput_stat=True) *Variable: Std (ifoutput_stat=True)- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"group_normalization"に登録されます。beta (
need_grad=True) : 学習可能な \(\beta\). (形状:<上記参照>)gamma (
need_grad=True) : 学習可能なスケーリングファクター \(\gamma\). (形状:<上記参照>)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = group_normalization(<args>)
- nnabla.parametric_functions.rnn(x, h, w0_init=None, w_init=None, b_init=None, num_layers=1, nonlinearity='tanh', dropout=0.0, bidirectional=False, training=True, rng=None, with_bias=True, fix_parameters=False, name=None)[ソース]
N-Step RNN (回帰型ニューラルネットワーク)。
N-Step RNN function implements Elman RNN with nonlinearity to input sequence. N-Step RNN function is defined as following:
\[h_t = \tanh(w_{ih}x_t+b_{ih}+w_{hh}h_{(t-1)}).\]これ以降の入力や出力の説明には、以下の表記を利用します。 \(T\): シーケンスの長さ、 \(B\): バッチサイズ、 \(I\): 入力サイズ、 \(L\): 層数、 \(D\): 方向数（１もしくは２）、 \(H\): 隠れサイズ。
参照
Jeffrey L. Elman. "Finding Structure in Time." Cognitive Science. 1990.
- パラメータ:
x (Variable) -- \((T, B, I)\) の形状の入力 N-D 配列。
h (Variable) -- \((L, D, B, H)\) の形状の入力 N-D 配列。
w0_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- 最初の層での重みのイニシャライザー。 形状は \((D, H, I + H)\) 。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- 二番目、それ以上の層での重みのイニシャライザー。 形状は \((L-1, D, H, D*H + H)\) 。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- バイアスのイニシャライザー。形状は \((L, D, H)\) 。num_layers (int, optional) -- ネットワーク内のレイヤー数。 1 に設定すると、最初のレイヤーの重みのみが呼び出されます。デフォルトは 1 です。
nonlinearity (str, optional) -- 入力シーケンスに適用される非線形演算の種類。 tanh または relu である必要があります。デフォルトは tanh です。
dropout (float, optional) -- パラメータに適用されるドロップアウトの割合。デフォルトは 0.0 です。
bidirectional (bool, optional) -- Trueの場合、各層で双方向計算が実行されます。デフォルトは False です。
training (bool, optional) -- True の場合のみ、Backpropagation が実行されます。デフォルトは True です。
with_bias (bool, optional) -- バイアス項を含めるか否かを指定します。
- 戻り値:
Output \(y\) with shape \((T, B, D * H)\) ~nnabla.Variable: Output \(h_n\) with shape \((L, D, B, H)\)
- 戻り値の型:
サンプル
x = nn.Variable((seq_len, batch_size, input_size)) h = nn.Variable((num_layers, num_directions, batch_size, hidden_size)) y, hn = PF.rnn(x, h)
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"rnn"に登録されます。weight_l0 (
need_grad=True) : 第０層でのフィルターの重み (形状:(D, H, I + H))weight (
need_grad=True) : 第１層以上でのフィルターの重み (形状:(L-1, D, H, DH + H))bias (
need_grad=True) : バイアス。 (形状:(L, D, H))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = rnn(<args>)
- nnabla.parametric_functions.lstm(x, h, c, w0_init=None, w_init=None, b_init=None, num_layers=1, dropout=0.0, bidirectional=False, training=True, rng=None, with_bias=True, fix_parameters=False, name=None)[ソース]
LSTM (long short-term memory).
Long Short-Term Memory (LSTM) は、回帰型ニューラルネットワーク (RNN) 層を構成するための要素の一つです。LSTM ユニットは、セルと入力、出力、忘却ゲートで構成され、その関数は以下のように定義されます。
\[\begin{split}f_t&&=\sigma(W_fx_t+U_fh_{t-1}+b_f) \\ i_t&&=\sigma(W_ix_t+U_ih_{t-1}+b_i) \\ o_t&&=\sigma(W_ox_t+U_oh_{t-1}+b_o) \\ c_t&&=f_t\odot c_{t-1}+i_t\odot\tanh(W_cx_t+U_ch_{t-1}+b_c) \\ h_t&&=o_t\odot\tanh(c_t).\end{split}\]これ以降の入力や出力の説明には、以下の表記を利用します。 \(T\): シーケンスの長さ、 \(B\): バッチサイズ、 \(I\): 入力サイズ、 \(L\): 層数、 \(D\): 方向数（１もしくは２）、 \(H\): 隠れサイズ。
参照
S. Hochreiter, and J. Schmidhuber. "Long Short-Term Memory." Neural Computation. 1997.
- パラメータ:
x (Variable) -- \((T, B, I)\) の形状の入力 N-D 配列。
h (Variable) -- \((L, D, B, H)\) の形状の入力 N-D 配列。
c (Variable) -- \((L, D, B, H)\) の形状の入力 N-D 配列。
w0_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- 最初の層での重みのイニシャライザー。 形状は \((D, 4, H, I + H)\) です。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- オプション) – 二番目、それ以上の層での重みのイニシャライザー。 形状は \((L-1, D, 4, H, D * H + H)\) です。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- バイアスのイニシャライザー。形状は \((L, D, 4, H)\) です。num_layers (int, optional) -- ネットワーク内のレイヤー数。 1 に設定すると、最初のレイヤーの重みのみが呼び出されます。デフォルトは 1 です。
dropout (float, optional) -- パラメータに適用されるドロップアウトの割合。デフォルトは 0.0 です。
bidirectional (bool, optional) -- Trueの場合、各層で双方向計算が実行されます。デフォルトは False です。
training (bool, optional) -- True の場合のみ、Backpropagation が実行されます。デフォルトは True です。
with_bias (bool, optional) -- バイアス項を含めるか否かを指定します。
- 戻り値:
\((T, B, D * H)\) の形状の出力 \(y\) ~nnabla.Variable: \((L, D, B, H)\) の形状の出力 \(h_n\) ~nnabla.Variable: \((L, D, B, H)\) の形状の出力 \(c_n\)
- 戻り値の型:
サンプル
x = nn.Variable((seq_len, batch_size, input_size)) h = nn.Variable((num_layers, num_directions, batch_size, hidden_size)) c = nn.Variable((num_layers, num_directions, batch_size, hidden_size)) y, hn, cn = PF.lstm(x, h, c)
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"lstm"に登録されます。weight_l0 (
need_grad=True) : 第 0 層でのフィルターの重み (形状:(D, 4, H, I + H))weight (
need_grad=True) : 第 1 層以上でのフィルターの重み (形状:(L-1, D, 4, H, DH + H))bias (
need_grad=True) : バイアス (形状:(L, D, 4, H))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = lstm(<args>)
- nnabla.parametric_functions.gru(x, h, w0_init=None, w_init=None, b_init=None, num_layers=1, dropout=0.0, bidirectional=False, training=True, rng=None, with_bias=True, fix_parameters=False, name=None)[ソース]
GRU (gated recurrent units)
GRU は、以下の通り定義されます。
\[\begin{split}r_t&&=\sigma(W_rx_t+U_rh_{t-1}+b_r) \\ z_t&&=\sigma(W_zx_t+U_zh_{t-1}+b_z) \\ n_t&&=\tanh(W_nx_t+b_{in}+r_n \odot (U_nh_{t-1}+b_{hn})) \\ h_t&&=(1-z_t) \odot n_t+z_t \odot h_{t-1}.\end{split}\]これ以降の入力や出力の説明には、以下の表記を利用します。 \(T\): シーケンスの長さ、 \(B\): バッチサイズ、 \(I\): 入力サイズ、 \(L\): 層数、 \(D\): 方向数（１もしくは２）、 \(H\): 隠れサイズ。
参照
K. Cho et al. "Learning Phrase Representations using RNN Encoder--Decoder for Statistical Machine Translation." Empirical Methods in Natural Language Processing. 2014.
- パラメータ:
x (Variable) -- \((T, B, I)\) の形状の入力 N-D 配列。
h (Variable) -- \((L, D, B, H)\) の形状の入力 N-D 配列。
w0_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- 最初の層での重みのイニシャライザー。 形状は \((D, 3, H, I + H)\) です。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- オプション) – 二番目、それ以上の層での重みのイニシャライザー。 形状は \((L-1, D, 3, H, D * H + H)\) です。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- バイアスのイニシャライザー。形状は \((L, D, 4, H)\) です。num_layers (int, optional) -- ネットワーク内のレイヤー数。 1 に設定すると、最初のレイヤーの重みのみが呼び出されます。デフォルトは 1 です。
dropout (float, optional) -- パラメータに適用されるドロップアウトの割合。デフォルトは 0.0 です。
bidirectional (bool, optional) -- Trueの場合、各層で双方向計算が実行されます。デフォルトは False です。
training (bool, optional) -- True の場合のみ、Backpropagation が実行されます。デフォルトは True です。
with_bias (bool, optional) -- バイアス項を含めるか否かを指定します。
- 戻り値:
Output \(y\) with shape \((T, B, D * H)\) ~nnabla.Variable: Output \(h_n\) with shape \((L, D, B, H)\)
- 戻り値の型:
サンプル
x = nn.Variable((seq_len, batch_size, input_size)) h = nn.Variable((num_layers, num_directions, batch_size, hidden_size)) y, hn = PF.gru(x, h)
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"gru"に登録されます。weight_l0 (
need_grad=True) : 第０層でのフィルターの重み (形状:(D, 3, H, I + H))weight (
need_grad=True) : 第１層以上でのフィルターの重み (形状:(L-1, D, 3, H, DH + H))bias (
need_grad=True) : バイアス (形状:(L, D, 4, H))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = gru(<args>)
- nnabla.parametric_functions.embed(inp, n_inputs, n_features, initializer=None, fix_parameters=False, apply_w=None, name=None)[ソース]
Embed (埋め込み)。
Embed は、インデックス配列／テンソルを使って、配列／テンソルをスライスします。重みは、
nnabla.initializer.UniformInitializerを使って \(-\sqrt{3}\) から \(\sqrt{3}\) の範囲内に初期化されます。- パラメータ:
- 戻り値:
\((I_0, ..., I_N, W_1, ..., W_M)\) の形状の出力
- 戻り値の型:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"embed"に登録されます。W (
need_grad=True) : 埋め込み行列 (形状:(n_inputs, n_features))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = embed(<args>)
- nnabla.parametric_functions.prelu(inp, base_axis=1, shared=True, fix_parameters=False, slope_init=None, name=None)[ソース]
次のように定義されたパラメータ化された正規化線形ユニット関数。
\[y_i = \max(0, x_i) + w_i \min(0, x_i)\]ここでは、負の傾き \(w\) が学習され、チャネル ( base_axis で指定された軸) 間で変化します。重みは \(-1\) で初期化されます。
- パラメータ:
x (Variable) -- 入力 N-D 配列
base_axis (int) -- base_axis までの次元は、サンプル次元として扱われます。
shared (bool) -- 共有の重み値を使用するか否か
slope_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 負の傾きのイニシャライザー。デフォルトでは、0.25で初期化されます。
- 戻り値:
N-D 配列
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"prelu"に登録されます。slope (
need_grad=True) : 負の傾き(形状:共有されている場合は tuple() それ以外は (inp.shape[base_axis],))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = prelu(<args>)
- nnabla.parametric_functions.svd_affine(inp, n_outmaps, r, base_axis=1, uv_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
SVD Affine (特異値分解 Affine) は、Affine 層の低ランク近似です。ボトルネックのある 2 つの連続した Affine 層と見なすことができます。次のように計算します。
\[{\mathbf y} = {\mathbf U} {\mathbf V} {\mathbf x} + {\mathbf b}.\]ここで、 \({\mathbf x}, {\mathbf y}\) はそれぞれ入力と出力で、 \({\mathbf U}, {\mathbf V}, {\mathbf b}\) は定数です。
重み \({\mathbf U}\) と \({\mathbf V}\) は、元の重み行列 \({\mathbf W}\) の特異値分解 ( SVD ) を使って、 \({R}\) 個の支配的な特異値と対応する特異ベクトルを選択することによって近似します。したがって、低ランク \({R}\) はボトルネックのサイズとなります。
uv_initが numpy 配列の場合、 \({\mathbf U}\) と \({\mathbf V}\) は、uv_initが \({\mathbf{UV}}\) で近似されるように計算されます。uv_initがNoneまたはイニシャライザーの場合、 \({\mathbf U}\) と \({\mathbf V}\) の積はランダムな初期値を近似します。\({\mathbf U}\) と \({\mathbf V}\) がコンテキストに存在する場合、それらは
uv_initよりも優先されます。Affine の重みが \({I \times O}\) で、指定する圧縮率が \({CR}\) とすると、 \({R}\) を次のように設定できます。
\[R = \left\lfloor \frac{(1 - CR)OI}{O + I} \right\rfloor.\]- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列となるように平坦化されます。
r (int) -- 分解された層のランク (ボトルネックのサイズ)
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。uv_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
\((B + 1)\)-D 配列。 (\(M_0 \times \ldots \times M_{B-1} \times L\))
- 戻り値の型:
- 登録されるパラメータ
以下の変数がパラメータスコープ
"svd_affine"に登録されます。U (
need_grad=True) : \({\mathbf U}\). (形状:(inmaps, r))V (
need_grad=True) : \({\mathbf V}\). (形状:(r, outmaps))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = svd_affine(<args>)
- nnabla.parametric_functions.svd_convolution(inp, outmaps, kernel, r, pad=None, stride=None, dilation=None, uv_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
SVD convolution (特異値分解 convolution) は、convolution 層を低ランク近似します。これは、depth wise convolution に続く 1 x 1 convolution と見なすことができます。
i 番目の入力マップの平坦化されたカーネルは、それらの低ランクの近似で表されます。 i 番目のインプット \({\mathbf W_i}\) のカーネルは、特異値分解 ( SVD )を利用して、 \({R}\) 個の支配的な特異値と対応する特異ベクトルを選択することで近似されます。
\[{\mathbf W_{:,i,:}} ~ {\mathbf U_i} {\mathbf V_i}.\]\({\mathbf U}\) は、乗数 \({R}\) を使った depthwise convolution の重さを含み、 \({\mathbf V}\) は 1 x 1 convolution の重みを含みます。
uv_initが numpy 配列の場合、 \({\mathbf U}\) と \({\mathbf V}\) は、uv_initが \({\mathbf{UV}}\) で近似されるように計算されます。uv_initがNoneまたはイニシャライザーの場合、 \({\mathbf U}\) と \({\mathbf V}\) の積はランダムな初期値を近似します。\({\mathbf U}\) と \({\mathbf V}\) がコンテキストに存在する場合、それらは
uv_initよりも優先されます。convolution のカーネルテンソルが \({O \times I \times K \times K}\) であり、指定する圧縮率が \({CR}\) であるとすると、 \({R}\) は次のように設定できます。
\[R = \left\lfloor \frac{(1 - CR)OIK^2}{I(O + K^2)} \right\rfloor.\]- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (tuple) -- カーネルサイズ。例えば、入力に対して3 (高さ) x 5 (幅) の 2 次元カーネルによる convlution を適用するには、( 3, 5 ) を指定します。
r (int) -- 分解された層のランク。
uv_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
\((B + 1)\)-D 配列。 (\(M_0 \times \ldots \times M_{B-1} \times L\))
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"svd_conv"に登録されます；U (
need_grad=True) : 分解フィルターの重み \({\mathbf U}\). (形状:(inmaps * r, *kernel))V (
need_grad=True) : 分解フィルターの重み \({\mathbf V}\). (形状:(outmaps, inmaps * r, 1, ...))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = svd_convolution(<args>)
- nnabla.parametric_functions.cpd3_convolution(inp, outmaps, kernel, r, pad=None, stride=None, dilation=None, oik_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, max_iter=500, stopping_criterion=1e-05, lambda_reg=0.0, name=None)[ソース]
CP convolution は、convolution 層の低ランク近似です。パラメータを含む 3D テンソルは、 N-D カーネルを 1 D に折り畳むことによって構築され、そのテンソルは 3 つの行列に分解されます。分解されたレイヤーは、特徴マップ \({R}\) に対する入力特徴マップの線形結合と見なされ、その後、depthwise convolution が続き、その後に出力マップを計算するための特徴マップの線形結合が続きます。
CP 分解では、次の形式のランク 1 テンソル \({R}\) により、カーネルテンソルに近似させることができます。
\[\sum_{r=1}^{R} \lambda_r {\mathbf{o}^{(r)} \otimes \mathbf{i}^{(r)} \otimes \mathbf{k}^{(r)}},\]ここで、 \({\lambda}_r\) は正規化係数、 \({\otimes}\) は外積です。
oik_initが numpy 配列の場合、U と V は uv_init が UV から近似できるように計算されます。oik_initが None またはイニシャライザーの場合、 U と V の積はランダムに初期化された配列を近似します。O、I、およびKがコンテキスト内に存在する場合、それらは層の初期化に使用され、oik_init は使用されません。Affine のカーネルテンソルが \({I \times O}\) で、指定する圧縮率が \({CR}\) であるとすると、 \({R}\) は次のように設定することができます。
\[R = \left\lfloor \frac{(1 - CR)OIK^2}{O + I + K^2} \right\rfloor.\]参照
Lebedev, Vadim, Yaroslav Ganin, Maksim Rakhuba, Ivan Oseledets, and Victor Lempitsky, "Speeding-up convolutional neural networks using fine-tuned cp-decomposition.", arXiv preprint arXiv:1412.6553 (2014).
Marcella Astrid, Seung-Ik Lee, "CP-decomposition with Tensor Power Method for Convolutional Neural Networks Compression", BigComp 2017.
- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。r (int) -- 因数分解された層のランク。
oik_init (numpy array or
nnabla.initializer.BaseInitializer) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
max_iter (int) -- ALSの最大イテレーション。
stopping_criterion (float) -- ALS を停止するための閾値。値が負の場合、収束チェックは無視されます。つまり、計算時間を短縮することができます。
lambda_reg (float) -- ALS の正則化パラメータ。 lambda_reg が大きいほど、正則化が大きくなります。
- 戻り値:
\((B + 1)\)-D 配列。 (\(M_0 \times \ldots \times M_{B-1} \times L\))
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"cpd3_conv"に登録されます。I (
need_grad=True) : 分解フィルターの重み \({\mathbf I}\). (形状:(r, inmaps, 1, ...))K (
need_grad=True) : 分割フィルターの重み \({\mathbf K}\). (形状:(r, *kernel))O (
need_grad=True) : 分解フィルターの重み \({\mathbf O}\). (形状:(outmaps, r, 1, ...))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = cpd3_convolution(<args>)
- nnabla.parametric_functions.binary_connect_affine(inp, n_outmaps, base_axis=1, quantize_zero_to=1.0, w_init=None, wb_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
Binary Connect Affine は、乗算なしの内積です。
Binary Connect Affine は Affine 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_i = \sum_{i} sign(w_i) x_i.\]したがって、 \(sign(w_i)\) は \(1\) または \(-1\) であり、内積は加算に単純化されます。
この関数は、Batch Normalization と併せて使用する必要があります。
参照
M. Courbariaux, Y. Bengio, and J.-P. David. "BinaryConnect: Training Deep Neural Networks with binary weights during propagations." Advances in Neural Information Processing Systems. 2015.
注釈
1 ) 複数の層で重みを共有したい場合は、バイナリ化された重み (
binary_weight) ではなく、通常の浮動小数点表現での重み (weight) を共有してください。2 ) 重みとバイナリの重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点表現の重みとバイナリの重みが同期されません。3 ) この関数はシミュレーション専用であるため、量子化された値は
binary_weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列となるように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。quantize_zero_to (float) -- ゼロでの入力値は、この値に量子化されます。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。wb_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイナリの重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
- 戻り値:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"bicon_affine"に登録されます。W (
need_grad=True) : 浮動小数点表現での重み行列。 (形状:(inmaps, outmaps))Wb (
need_grad=False) : バイナリ化された重み。 (形状:(inmaps, outmaps))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = binary_connect_affine(<args>)
- nnabla.parametric_functions.binary_connect_convolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, quantize_zero_to=1.0, w_init=None, wb_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
Binary Connect Convolution は、乗算なしの内積です。
Binary Connect Convolution は convolution 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_{n, a, b} = \sum_{m} \sum_{i} \sum_{j} sign(w_{n, m, i, j}) x_{m, a + i, b + j}.\]したがって、 \(sign(w_i)\) は \(1\) または \(-1\) であり、内積は加算に単純化されます。
この関数は、BatchNormalization と共に使用する必要があります。
参照
M. Courbariaux, Y. Bengio, and J.-P. David. "BinaryConnect: Training Deep Neural Networks with binary weights during propagations." Advances in Neural Information Processing Systems. 2015.
注釈
1 ) 複数の層で重みを共有したい場合は、バイナリ化された重み (
binary_weight) ではなく、通常の浮動小数点表現での重み (weight) を共有してください。2 ) 重みとバイナリの重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点表現の重みとバイナリの重みが同期されません。3 ) この関数はシミュレーション専用であるため、量子化された値は
binary_weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
quantize_zero_to (float) -- ゼロでの入力値は、この値に量子化されます。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。wb_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイナリの重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"bicon_conv"に登録されます。W (
need_grad=True) : 浮動小数点表現におけるフィルターの重み。(形状:(outmaps, inmaps, *kernel))Wb (
need_grad=False) : バイナリ化されたフィルターの重み。(形状:(outmaps, inmaps, *kernel))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = binary_connect_convolution(<args>)
- nnabla.parametric_functions.binary_weight_affine(inp, n_outmaps, base_axis=1, quantize_zero_to=1.0, w_init=None, wb_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
Binary Weight Affine は、スケールファクターを伴う乗算なしの内積です。
Binary Weight Affine は Affine 関数ですが、この関数の内積は次のとおりです。
\[y_j = \frac{1}{\|\mathbf{w}_j\|_{\ell_1}} \sum_{i} sign(w_{ji}) x_i\]したがって、 \(sign(w_{ji})\) は \(1\) または \(-1\) であり、内積計算は加算とスケールファクター \(\alpha = \frac{1}{\|\mathbf{w}_j\|_{\ell_1}}\) による乗算に単純化されます。 \(\alpha\) の数が Affine 関数の outmaps となります。
参照
Rastegari, Mohammad, et al. "XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks." arXiv preprint arXiv:1603.05279 (2016).
注釈
1 ) 複数の層で重みを共有したい場合は、バイナリ化された重み (
binary_weight) ではなく、通常の浮動小数点表現での重み (weight) を共有してください。2 ) 重みとバイナリの重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点表現の重みとバイナリの重みが同期されません。3 ) この関数はシミュレーション専用であるため、量子化された値は
binary_weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列のように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。quantize_zero_to (float) -- ゼロでの入力値は、この値に量子化されます。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。wb_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイナリの重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"bwn_affine"に登録されます。W (
need_grad=True) : 浮動小数点表現での重み行列。 (形状:(inmaps, outmaps))Wb (
need_grad=False) : バイナリ化された重み。 (形状:(inmaps, outmaps))alpha (
need_grad=False) : スケールファクター \(\alpha\) (形状:(outmaps,))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = binary_weight_affine(<args>)
- nnabla.parametric_functions.binary_weight_convolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, quantize_zero_to=1.0, w_init=None, wb_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
Binary Weight Convolution は、スケールファクターを伴う乗算なしの内積です。
Binary Weight Convolution は、convolution 関数ですが、この関数の内積は次のとおりです。
\[y_{n, a, b} = \frac{1}{\|\mathbf{w}_n\|_{\ell_1}} \sum_{m} \sum_{i} \sum_{j} sign(w_{n, m, i, j}) x_{m, a + i, b + j}.\]したがって、 \(sign(w_{n, m, i, j})\) は \(1\) または \(-1\) であり、内積は加算とスケールファクター \(\alpha = \frac{1}{\|\mathbf{w}_n\|_{\ell_1}}\) による乗算に単純化されます。 \(n\) の数は、convolution 関数の outmaps の数です。
参照
Rastegari, Mohammad, et al. "XNOR-Net: ImageNet Classification Using Binary Convolutional Neural Networks." arXiv preprint arXiv:1603.05279 (2016).
注釈
1 ) 複数の層で重みを共有したい場合は、バイナリ化された重み (
binary_weight) ではなく、通常の浮動小数点表現での重み (weight) を共有してください。2 ) 重みとバイナリの重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点表現の重みとバイナリの重みが同期されません。3 ) この関数はシミュレーション専用であるため、量子化された値は
binary_weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
quantize_zero_to (float) -- ゼロでの入力値は、この値に量子化されます。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。wb_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイナリの重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"bwn_conv"に登録されます。W (
need_grad=True) : 浮動小数点表現におけるフィルターの重み。(形状:(outmaps, inmaps, *kernel))Wb (
need_grad=False) : バイナリ化されたフィルターの重み。(形状:(outmaps, inmaps, *kernel))alpha (
need_grad=False) : スケールファクター \(\alpha\) (形状:(outmaps,))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = binary_weight_convolution(<args>)
- nnabla.parametric_functions.inq_affine(inp, n_outmaps, base_axis=1, num_bits=4, inq_iterations=(), selection_algorithm='random', seed=-1, w_init=None, i_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
Incremental Network Quantization Affine (増分ネットワーク量子化 Affine) 層。
学習中、重みは順次 2 の累乗の値に量子化されます。これにより、乗算のないネットワークの学習が可能になります。
inq_iterationsを使用すると、学習可能な重みの半分が固定され、2 の累乗に量子化されるまでに forward パスを行う回数を指定することができます。inq_iterationsの最後の値に到達すると、すべての重みが固定されます。詳しくは以下をご参照ください。
参照: Zhou A, Yao A, Guo Y, Xu L, Chen Y. Incremental network quantization: Towards lossless CNNs with low-precision weights. <https://arxiv.org/abs/1702.03044>
- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列のように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。quantize_zero_to (float) -- ゼロでの入力値は、この値に量子化されます。
num_bits (int) -- 重みごとのビット数。1 ビットは値 "0" のコーディングにすでに使用されているため、値は 1 より大きくする必要があります。
selection_algorithm (str) -- 固定する重みを決定するために使用されるアルゴリズムを選択します。(“largest_abs” … 最大絶対値で重みを固定します。 “random” …重みをランダムに固定します。）
seed (int) -- Random seed for INQ algorithm
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。i_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- インジケーターのイニシャライザー (0 … 学習可能, 1 … 固定)。デフォルトでは、ゼロで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"inq_affine"に登録されます。W (
need_grad=True) : 浮動小数点表現での重み行列。 (形状:(inmaps, outmaps))I (
need_grad=False) : 固定の重みのバイナリインジケーター行列 (形状:(inmaps, outmaps))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = inq_affine(<args>)
- nnabla.parametric_functions.inq_convolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, num_bits=4, inq_iterations=(), selection_algorithm='random', seed=-1, w_init=None, i_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, name=None)[ソース]
Incremental Network Quantization Convolution (増分ネットワーク量子化 Convolution) 層
学習中、重みは順次 2 の累乗の値に量子化されます。これにより、乗算のないネットワークの学習が可能になります。
inq_iterationsを使用すると、学習可能な重みの半分が固定され、2 の累乗に量子化されるまでに forward パスを行う回数を指定することができます。inq_iterationsの最後の値に到達すると、すべての重みが固定されます。詳しくは以下をご参照ください。
参照: Zhou A, Yao A, Guo Y, Xu L, Chen Y. Incremental network quantization: Towards lossless CNNs with low-precision weights. <https://arxiv.org/abs/1702.03044>
- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列のように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。num_bits (int) -- 重みごとのビット数。1 ビットは値 "0" のコーディングにすでに使用されているため、値は 1 より大きくする必要があります。
selection_algorithm (str) -- 固定する重みを決定するために使用されるアルゴリズムを選択します。(“largest_abs” … 最大絶対値で重みを固定します。 “random” …重みをランダムに固定します。）
seed (int) -- Random seed for INQ algorithm
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。i_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- インジケーターのイニシャライザー (0 … 学習可能, 1 … 固定)。デフォルトでは、ゼロで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
- 戻り値:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"inq_conv"に登録されます。W (
need_grad=True) : 浮動小数点表現におけるフィルターの重み。(形状:(outmaps, inmaps, *kernel))I (
need_grad=False) : 固定の重みのバイナリインジケーター行列 (形状:(outmaps, inmaps, *kernel))b (
need_grad=True) : バイアスベクター (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = inq_convolution(<args>)
- nnabla.parametric_functions.fixed_point_quantized_affine(inp, n_outmaps, base_axis=1, w_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, quantize_w=True, sign_w=True, n_w=8, delta_w=0.0625, ste_fine_grained_w=True, quantize_b=True, sign_b=True, n_b=8, delta_b=0.0625, ste_fine_grained_b=True, name=None)[ソース]
Fixed-Point Quantized Affine (固定小数点量子化 Affine)
Fixed-Point Quantized Affine は Affine 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_j = \sum_{i} Q(w_{ji}) x_i,\]ここで \(Q(w_{ji})\) は fixed-point quantization 関数です。
注釈
1 ) 複数の層で重みを共有する場合は、量子化された重み (
quantized weight) ではなく、標準の浮動小数点の重み (weight) を共有してください。2 ) 重みと量子化された重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点の重みとバイナリの重みが同期しなくなります。3 ) この関数はシミュレーション専用であるため、量子化された値は
quantized weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列となるように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
n_w (int) -- 重みに使われるビット幅。
delta_w (float) -- 重みの間隔サイズ。
n_b (int) -- バイアスに使われるビット幅
delta_w -- バイアスの間隔サイズ。
- 戻り値:
\((B + 1)\)-D 配列。 (\(M_0 \times \ldots \times M_{B-1} \times L\))
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"fp_quantized_affine"に登録されます。W (
need_grad=True) : 浮動小数点による重みの行列 (形状:(inmaps, outmaps))b (
need_grad=True) : 浮動小数点によるバイアスベクトル (形状:(outmaps,))W_q (
need_grad=False) : 量子化された重み (形状:(inmaps, outmaps))b_q (
need_grad=False) : 量子化されたバイアス (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = fixed_point_quantized_affine(<args>)
- nnabla.parametric_functions.fixed_point_quantized_convolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, channel_last=False, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, quantize_w=True, sign_w=True, n_w=8, delta_w=0.0625, ste_fine_grained_w=True, quantize_b=True, sign_b=True, n_b=8, delta_b=0.0625, ste_fine_grained_b=True, name=None)[ソース]
Fixed-Point Quantized Convolution (固定小数点量子化 Convolution)
Fixed-Point Quantized Convolution は、convolution 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_{n, a, b} = \sum_{m} \sum_{i} \sum_{j} Q(w_{n, m, i, j}) x_{m, a + i, b + j},\]ここで \(Q(w_{n, m, i, j})\) は fixed-point quantization 関数です。
注釈
1 ) 複数の層で重みを共有する場合は、量子化された重み (
quantized weight) ではなく、標準の浮動小数点の重み (weight) を共有してください。2 ) 重みと量子化された重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点の重みとバイナリの重みが同期しなくなります。3 ) この関数はシミュレーション専用であるため、量子化された値は
quantized weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
n_w (int) -- 重みに使われるビット幅。
delta_w (float) -- 重みの間隔サイズ。
n_b (int) -- バイアスに使われるビット幅
delta_w -- バイアスの間隔サイズ。
- 戻り値:
N-D 配列
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"fp_quantized_conv"に登録されます。W (
need_grad=True) : 浮動小数点によるフィルターの重み (形状:(outmaps, inmaps // group, *kernel))b (
need_grad=True) : 浮動小数点によるバイアスベクトル (形状:(outmaps,))W_q (
need_grad=False) : 量子化された重み(形状:(outmaps, inmaps // group, *kernel))b_q (
need_grad=False) : 量子化されたバイアス (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = fixed_point_quantized_convolution(<args>)
- nnabla.parametric_functions.min_max_quantized_affine(inp, n_outmaps, base_axis=1, w_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, quantize_w=True, ql_min_w=0, ql_max_w=255, w_min_max=False, qr_min_w_init=None, qr_max_w_init=None, ste_fine_grained_w=True, quantize_b=True, ql_min_b=0, ql_max_b=255, b_min_max=False, qr_min_b_init=None, qr_max_b_init=None, ste_fine_grained_b=True, eps=0.01, name=None)[ソース]
Min-max Quantized Affine (最小最大量子化 Affine)
Min-max Quantized Affine は、Affine 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_j = \sum_{i} Q(w_{ji}) x_i,\]ここで \(Q(w_{ji})\) は min-max quantization 関数です。
Min-max Quantized Affine では、指数移動平均は使用されません。量子化範囲の最小値と最大値は、重みとバイアスの最小値と最大値であるか、学習によって決定されます。
入力の最小値と最大値は、常に指数移動平均の代わりに使用されることに注意してください。
注釈
1 ) 複数の層で重みを共有する場合は、量子化された重み (
quantized weight) ではなく、標準の浮動小数点の重み (weight) を共有してください。2 ) 重みと量子化された重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点の重みとバイナリの重みが同期しなくなります。3 ) この関数はシミュレーション専用であるため、量子化された値は
quantized weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列となるように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
ql_min_w (int, float, or Variable) -- 重みの最小量子化レベル。デフォルトは 0 です。
ql_max_w (int, float, or Variable) -- 重みの最大量子化レベル。デフォルトは 255 です。
w_min_max (bool) -- 量子化範囲を計算するために重みの最小値と最大値を使用します。デフォルトは
Falseです。qr_min_w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 最小量子化範囲のイニシャライザー、 qr_min 。デフォルトは、nnabla.initializer.ConstantInitializer(-2.0)。qr_max_w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- Initializer for the maximum quantization range, qr_max. Default isnnabla.initializer.ConstantInitializer(2.0).ste_fine_grained_w (bool) --
Trueの場合、STE は 1 ではなく、min-max から計算された {0、1} -マスクが backward の勾配に適用されます。それ以外の場合、STE は 1 です。ql_min_b (int, float, or Variable) -- バイアスの最小量子化レベル。デフォルトは 0 です。
ql_max_b (int, float, or Variable) -- バイアスの最大量子化レベル。デフォルトは 255 です。
b_min_max (bool) -- 量子化範囲を計算するためにバイアスの最小値と最大値を使用します。デフォルトは
Falseです。qr_min_b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 最小量子化範囲のイニシャライザー、 qr_min 。 デフォルトは、nnabla.initializer.ConstantInitializer(-6.0)。qr_max_b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- Initializer for the maximum quantization range, qr_max. Default isnnabla.initializer.ConstantInitializer(6.0).ste_fine_grained_b (bool) --
Trueの場合、STE は 1 ではなく、min-max から計算された {0、1} -マスクが backward の勾配に適用されます。それ以外の場合、STE は 1 です。eps (float) -- イプシロン、 \(qr_{max} - qr_{min}\) が確実に重みとバイアスの両方のイプシロンより大きくなるような小さな値。
- 戻り値:
\((B + 1)\)-D 配列。 (\(M_0 \times \ldots \times M_{B-1} \times L\))
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"min_max_quantized_affine"に登録されます。W (
need_grad=True) : 浮動小数点による重みの行列 (形状:(inmaps, outmaps))b (
need_grad=True) : 浮動小数点によるバイアスベクトル (形状:(outmaps,))W_q (
need_grad=False) : 量子化された重み (形状:(inmaps, outmaps))b_q (
need_grad=False) : 量子化されたバイアス (形状:(outmaps,))qr_min (
need_grad=False) : 最小量子化範囲。入力または学習可能な範囲の最小値 (形状:ql_min.shape)qr_max (
need_grad=False) : 最大量子化範囲。入力または学習可能な範囲の最大値 (形状:ql_max.shape)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = min_max_quantized_affine(<args>)
- nnabla.parametric_functions.min_max_quantized_convolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, channel_last=False, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, quantize_w=True, ql_min_w=0, ql_max_w=255, w_min_max=False, qr_min_w_init=None, qr_max_w_init=None, ste_fine_grained_w=True, quantize_b=True, ql_min_b=0, ql_max_b=255, b_min_max=False, qr_min_b_init=None, qr_max_b_init=None, ste_fine_grained_b=True, eps=0.01, name=None)[ソース]
Min-max Quantized Convolution (最小最大量子化 Convolution)
Min-max Quantized Convolution は、convolution 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_{n, a, b} = \sum_{m} \sum_{i} \sum_{j} Q(w_{n, m, i, j}) x_{m, a + i, b + j},\]ここでの \(Q(w_{n, m, i, j})\) は min-max quantization 関数です。
min_max_quantized convolution では、指数移動平均は使用されません。量子化範囲の最小値と最大値は、重みとバイアスの最小値と最大値であるか、学習によって決定されます。
入力の最小値と最大値は、常に指数移動平均の代わりに使用されることに注意してください。
注釈
1 ) 複数の層で重みを共有する場合は、量子化された重み (
quantized weight) ではなく、標準の浮動小数点の重み (weight) を共有してください。2 ) 重みと量子化された重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点の重みとバイナリの重みが同期しなくなります。3 ) この関数はシミュレーション専用であるため、量子化された値は
quantized weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
channel_last (bool) -- True の場合、最後の次元はチャネル次元になり、いわゆるNHWC 順になります。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
ql_min_w (int, float, or Variable) -- 重みの最小量子化レベル。デフォルトは 0 です。
ql_max_w (int, float, or Variable) -- 重みの最大量子化レベル。デフォルトは 255 です。
w_min_max (bool) -- 量子化範囲を計算するために重みの最小値と最大値を使用します。デフォルトは
Falseです。qr_min_w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 最小量子化範囲のイニシャライザー、 qr_min 。デフォルトは、nnabla.initializer.ConstantInitializer(-2.0)。qr_max_w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- Initializer for the maximum quantization range, qr_max Default isnnabla.initializer.ConstantInitializer(2.0).ste_fine_grained_w (bool) --
Trueの場合、STE は 1 ではなく、min-max から計算された {0、1} -マスクが backward の勾配に適用されます。それ以外の場合、STE は 1 です。ql_min_b (int, float, or Variable) -- バイアスの最小量子化レベル。デフォルトは 0 です。
ql_max_b (int, float, or Variable) -- バイアスの最大量子化レベル。デフォルトは 255 です。
b_min_max (bool) -- 量子化範囲を計算するためにバイアスの最小値と最大値を使用します。デフォルトは
Falseです。qr_min_b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 最小量子化範囲のイニシャライザー、 qr_min 。 デフォルトは、nnabla.initializer.ConstantInitializer(-6.0)。qr_max_b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- Initializer for the maximum quantization range, qr_max Default isnnabla.initializer.ConstantInitializer(6.0).ste_fine_grained_b (bool) --
Trueの場合、STE は 1 ではなく、min-max から計算された {0、1} -マスクが backward の勾配に適用されます。それ以外の場合、STE は 1 です。eps (float) -- イプシロン、 \(qr_{max} - qr_{min}\) が確実に重みとバイアスの両方のイプシロンより大きくなるような小さな値。
- 戻り値:
N-D 配列
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"min_max_quantized_conv"に登録されます。W (
need_grad=True) : 浮動小数点によるフィルターの重み (形状:(outmaps, inmaps // group, *kernel))b (
need_grad=True) : 浮動小数点によるバイアスベクトル (形状:(outmaps,))W_q (
need_grad=False) : 量子化された重み(形状:(outmaps, inmaps // group, *kernel))b_q (
need_grad=False) : 量子化されたバイアス (形状:(outmaps,))qr_min (
need_grad=False) : 最小量子化範囲。入力または学習可能な範囲の最小値 (形状:ql_min.shape)qr_max (
need_grad=False) : 最大量子化範囲。入力または学習可能な範囲の最大値 (形状:ql_max.shape)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = min_max_quantized_convolution(<args>)
- nnabla.parametric_functions.pow2_quantized_affine(inp, n_outmaps, base_axis=1, w_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, quantize_w=True, sign_w=True, with_zero_w=False, n_w=8, m_w=2, ste_fine_grained_w=True, quantize_b=True, sign_b=True, with_zero_b=False, n_b=8, m_b=2, ste_fine_grained_b=True, name=None)[ソース]
Pow2 Quantized Affine ( 2 のべき乗量子化 Affine)
Pow2 Quantized Affine は、Affine 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_j = \sum_{i} Q(w_{ji}) x_i,\]ここで \(Q(w_{ji})\) は 2のべき乗量子化関数です。
注釈
1 ) 複数の層で重みを共有する場合は、量子化された重み (
quantized weight) ではなく、標準の浮動小数点の重み (weight) を共有してください。2 ) 重みと量子化された重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点の重みとバイナリの重みが同期しなくなります。3 ) この関数はシミュレーション専用であるため、量子化された値は
quantized weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列となるように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
with_zero_w (bool) -- 量子化値としてゼロを使用することを示します。デフォルトは false です。
n_w (int) -- 重みに使われるビット幅。
m_w (int) -- 重みにおいて \(2^m\) は上限、 \(-2^m\) は下限となります。デフォルトは2です。
with_zero_b (bool) -- 量子化値としてゼロを使用することを示します。デフォルトは false です。
n_b (int) -- バイアスに使われるビット幅
m_b (int) -- バイアスにおいて \(2^m\) は上限、 \(-2^m\) は下限となります。デフォルトは2です。
- 戻り値:
\((B + 1)\)-D 配列。 (\(M_0 \times \ldots \times M_{B-1} \times L\))
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"pow2_quantized_affine"に登録されます。W (
need_grad=True) : 浮動小数点による重みの行列 (形状:(inmaps, outmaps))b (
need_grad=True) : 浮動小数点によるバイアスベクトル (形状:(outmaps,))W_q (
need_grad=False) : 量子化された重み (形状:(inmaps, outmaps))b_q (
need_grad=False) : 量子化されたバイアス (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = pow2_quantized_affine(<args>)
- nnabla.parametric_functions.pow2_quantized_convolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, quantize_w=True, with_zero_w=False, sign_w=True, n_w=8, m_w=2, ste_fine_grained_w=True, quantize_b=True, with_zero_b=False, sign_b=True, n_b=8, m_b=2, ste_fine_grained_b=True, name=None)[ソース]
Pow2 Quantized Convolution ( 2 のべき乗量子化 Convolution)
Pow2 Quantized Convolution は、convolution 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_{n, a, b} = \sum_{m} \sum_{i} \sum_{j} Q(w_{n, m, i, j}) x_{m, a + i, b + j},\]ここで \(Q(w_{n, m, i, j})\) は2のべき乗量子化関数です。
注釈
1 ) 複数の層で重みを共有する場合は、量子化された重み (
quantized weight) ではなく、標準の浮動小数点の重み (weight) を共有してください。2 ) 重みと量子化された重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点の重みとバイナリの重みが同期しなくなります。3 ) この関数はシミュレーション専用であるため、量子化された値は
quantized weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
n_w (int) -- 重みに使われるビット幅。
m_w (int) -- 重みにおいて \(2^m\) は上限、 \(-2^m\) は下限となります。デフォルトは2です。
n_b (int) -- バイアスに使われるビット幅
m_b (int) -- バイアスにおいて \(2^m\) は上限、 \(-2^m\) は下限となります。デフォルトは2です。
- 戻り値:
N-D 配列
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"pow2_quantized_conv"に登録されます。W (
need_grad=True) : 浮動小数点によるフィルターの重み (形状:(outmaps, inmaps // group, *kernel))b (
need_grad=True) : 浮動小数点によるバイアスベクトル (形状:(outmaps,))W_q (
need_grad=False) : 量子化された重み(形状:(outmaps, inmaps // group, *kernel))b_q (
need_grad=False) : 量子化されたバイアス (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = pow2_quantized_convolution(<args>)
- nnabla.parametric_functions.pruned_affine(inp, n_outmaps, base_axis=1, w_init=None, b_init=None, fix_parameters=False, rng=None, with_bias=True, prune_w=True, rate_w=0.9, prune_b=True, rate_b=0.9, name=None)[ソース]
Pruned Affine (枝刈りされた Affine)
Pruned Affine は、Affine 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_j = \sum_{i} Q(w_{ji}) x_i,\]ここで \(Q(w_{ji})\) は pruning 関数、すなわち
F.pruneです。注釈
1 ) 複数の層で重みを共有する場合は、量子化された重み (
quantized weight) ではなく、標準の浮動小数点の重み (weight) を共有してください。2 ) 重みと量子化された重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点の重みとバイナリの重みが同期しなくなります。3 ) この関数はシミュレーション専用であるため、量子化された値は
quantized weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- (\(M_0 \times \ldots \times M_{B-1} \times D_B \times \ldots \times D_N\)) の形状の入力 N-D 配列。base_axis 前後の次元は、行列となるように平坦化されます。
base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
rate_w (float) -- 重みの pruning (枝刈りする) 割合
rate_b (float) -- バイアスの pruning (枝刈りする) 割合
- 戻り値:
\((B + 1)\)-D 配列。 (\(M_0 \times \ldots \times M_{B-1} \times L\))
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"pruned_affine"に登録されます。W (
need_grad=True) : 浮動小数点による重みの行列 (形状:(inmaps, outmaps))b (
need_grad=True) : 浮動小数点によるバイアスベクトル (形状:(outmaps,))W_q (
need_grad=False) : 量子化された重み (形状:(inmaps, outmaps))b_q (
need_grad=False) : 量子化されたバイアス (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = pruned_affine(<args>)
- nnabla.parametric_functions.pruned_convolution(inp, outmaps, kernel, pad=None, stride=None, dilation=None, group=1, channel_last=False, w_init=None, b_init=None, base_axis=1, fix_parameters=False, rng=None, with_bias=True, prune_w=True, rate_w=0.9, prune_b=True, rate_b=0.9, name=None)[ソース]
Pruned Convolution (枝刈りされた Convolution)
Pruned Convolution は、convolution 関数ですが、内積の定義が変更されています。この関数の入出力関係は次のとおりです。
\[y_{n, a, b} = \sum_{m} \sum_{i} \sum_{j} Q(w_{n, m, i, j}) x_{m, a + i, b + j},\]ここで \(Q(w_{ji})\) は pruning 関数、すなわち
F.pruneです。注釈
1 ) 複数の層で重みを共有する場合は、量子化された重み (
quantized weight) ではなく、標準の浮動小数点の重み (weight) を共有してください。2 ) 重みと量子化された重みは、
forward()が呼び出された後にのみ同期され、backward()への呼び出し後では同期されません。ネットワークのパラメータにアクセスする前には、必ずforward()を 1 回呼び出してください。これを行わないと、浮動小数点の重みとバイナリの重みが同期しなくなります。3 ) この関数はシミュレーション専用であるため、量子化された値は
quantized weightの浮動小数点数として格納されます。- パラメータ:
inp (Variable) -- N-D 配列
outmaps (int) -- convolution カーネルの数（出力チャネルの数）。例えば、入力に対して、16 種類のフィルターによるconvolution を適用するには、16を指定します。
kernel (
tupleofint) -- convolution カーネルのサイズ。例えば、画像に対して、3（高さ）x 5（幅）の 2 次元カーネルによる convolution を適用するには、( 3, 5 ) を指定します。group (int) -- チャネルのグループ数。これにより、マップ方向に沿って接続をグループ化することにより、チャネル間の接続がよりスパースになります。
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 重みのイニシャライザー。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- バイアスのイニシャライザー。base_axis (int) --
base_axisまでの次元は、サンプル次元として扱われます。rng (numpy.random.RandomState) -- イニシャライザーのためのランダムジェネレーター。
with_bias (bool) -- バイアス項を含めるか否かを指定します。
rate_w (float) -- 重みの pruning (枝刈りする) 割合
rate_b (float) -- バイアスの pruning (枝刈りする) 割合
- 戻り値:
N-D 配列
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"pruned_conv"に登録されます。W (
need_grad=True) : 浮動小数点によるフィルターの重み (形状:(outmaps, inmaps // group, *kernel))b (
need_grad=True) : 浮動小数点によるバイアスベクトル (形状:(outmaps,))W_q (
need_grad=False) : 量子化された重み(形状:(outmaps, inmaps // group, *kernel))b_q (
need_grad=False) : 量子化されたバイアス (形状:(outmaps,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = pruned_convolution(<args>)
- nnabla.parametric_functions.min_max_quantize(x, ql_min=0, ql_max=255, decay=0.999, x_min_max=False, ema=False, ste_fine_grained=True, eps=0.01, qr_min_init=None, qr_max_init=None, fix_parameters=False, outputs=None, name=None)[ソース]
Min-max quantization (最小最大量子化)
この関数は、最小および最大量子化レベルの範囲の値を均一に量子化します。
最小最大量子化は、次の方程式として定義されます。
\[y = round \left(\frac{\min(\max(x, m), M) - m}{scale} \right) \times scale + m,\]ここで、 \(scale\) は次のように定義されます。
\[scale = \frac{M - m}{M_q - m_q},\]そして
\[\begin{split}m_q = ql_{min}, \\ M_q = ql_{max}, \\ m = qr_{min}, \\ M = qr_{max}.\end{split}\]backward パスにおいて
ste_fine_grainedが false として使われる時、\[\frac{\partial q_i}{\partial x_i} = 1.\]backward パスにおいて
ste_fine_grainedが True として使われる時、\[\begin{split} \frac{\partial q_i}{\partial x_i}= \left\{ \begin{array}{ll} 0 & if \ \ \ x_i > M \\ 1 & if \ \ m \le x_i \le M \\ 0 & if \ \ x_i < m \\ \end{array} \right..\end{split}\]\(qr_{min}\) と \(qr_{max}\) は以下のように扱われます。
x_min_maxがTrueで、emaがTrueの場合： \(min(x)\) および \(max(x)\) ごとに指数移動平均が計算され、 \(qr_{min}\) および \(qr_{max}\) に格納されます。x_min_maxがTrueで、emaがFalseの場合： \(min(x)\) と \(max(x)\) が計算され、 \(qr_{min}\) と \(qr_{max}\) に格納されます。x_min_maxがFalseで、emaがTrueの場合： \(qr_{min}\) と \(qr_{max}\) に格納されている指数移動平均が使用されます。x_min_maxがFalseで、emaがFalseの場合： \(qr_{min}\) と \(qr_{max}\) の勾配は、backward パスで計算されます。
より正確には、min-max quantization の推論では、実際の値 0 に対応する ゼロ点 ( zp ) を考慮する必要があり、そのデータ型は整数です。 ゼロポイント は次のように定義されます
\[\begin{split} && zp_f = ql_{min} -\frac{qr_{min}}{scale}, \\ && zp = \left\{ \begin{array}{ll} ql_{max} & if \ \ \ zp_f >= ql_{max} \\ round(zp_f) & if \ \ otherwise \\ ql_{min} & if \ \ zp_f <= ql_{min} \\ \end{array} \right..\end{split}\]したがって、 ゼロ点 の量子化効果をシミュレートするために、forward パスと backward パスの両方で、 \(qr_{min}\) と \(qr_{max}\) は次のように調整されます。
\[\begin{split}qr_{min}^{adj} = ql_{min} - zp * scale, \\ qr_{max}^{adj} = ql_{max} - zp * scale.\end{split}\]これらの操作は nudge と呼ばれます。
最後に、min-max quantization の式では、 \(m\) と \(M\) はそれぞれ \(qr_{min}^{adj}\) と \(qr_{max}^{adj}\) に置き換えられます。
- パラメータ:
x (Variable) -- 入力 N-D 配列。
decay (float) -- 指数移動平均の減衰率。
x_min_max (bool) -- 量子化範囲を計算するために、 x の最小値と最大値を使用します。デフォルトは
Falseです。ste_fine_grained (bool) --
Trueの場合、STE は 1 ではなく、min-max から計算された {0、1} -マスクが backward の勾配に適用されます。それ以外の場合、STE は 1 です。eps (float) -- イプシロン、 \(qr_{max} - qr_{min}\) が確実に重みとバイアスの両方のイプシロンより大きくなるような小さな値。
qr_min_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- 最小量子化範囲のイニシャライザー、 qr_min 。 デフォルトは、nnabla.initializer.ConstantInitializer(-6.0)。qr_max_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- Initializer for the maximum quantization range, qr_max Default isnnabla.initializer.ConstantInitializer(6.0).
参照
Benoit Jacob, Skirmantas Kligys, Bo Chen, Menglong Zhu, Matthew Tang, Andrew Howard, Hartwig Adam, and Dmitry Kalenichenko, "Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference", https://arxiv.org/abs/1712.05877
- 登録されるパラメータ
次の変数は、パラメータスコープ
"min_max_quantize"に登録されます。qr_min (
need_grad=False) : 最小量子化範囲、 ema が True の場合、-6.0 で初期化された入力の最小値の指数移動平均 (形状:ql_min.shape)qr_max (
need_grad=False) : 最大量子化範囲、 ema が True の場合に 6.0 で初期化された入力の最大値の指数移動平均。(形状:ql_max.shape)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = min_max_quantize(<args>)
- nnabla.parametric_functions.lstm_cell(x, h, c, state_size, w_init=None, b_init=None, fix_parameters=False, name=None)[ソース]
Long Short-Term Memory (長・短期記憶)
Long Short-Term Memory (LSTM) は、回帰型ニューラルネットワーク (RNN) 層を構成するための要素の一つです。LSTM ユニットは、セルと入力、出力、忘却ゲートで構成され、その関数は以下のように定義されます。
\[\begin{split}f_t&&=\sigma(W_fx_t+U_fh_{t-1}+b_f) \\ i_t&&=\sigma(W_ix_t+U_ih_{t-1}+b_i) \\ o_t&&=\sigma(W_ox_t+U_oh_{t-1}+b_o) \\ c_t&&=f_t\odot c_{t-1}+i_t\odot\tanh(W_cx_t+U_ch_{t-1}+b_c) \\ h_t&&=o_t\odot\tanh(c_t).\end{split}\]参照
S. Hochreiter, and J. Schmidhuber. "Long Short-Term Memory." Neural Computation. 1997.
- パラメータ:
x (Variable) -- Input N-D array with shape (batch_size, input_size).
h (Variable) -- (batch_size, state_size) の形状の入力 N-D 配列。
c (Variable) -- (batch_size, state_size) の形状の入力 N-D 配列。
state_size (int) -- 内部状態サイズは
state_sizeに設定されます。w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。
- 戻り値:
- 登録されるパラメータ
以下の変数は、パラメータスコープ
"lstm"に登録されます。affine/W (
need_grad=True) : LSTM ブロックの重み行列(形状:(inmaps, 4, state_size))affine/b (
need_grad=True) : LSTM ブロックのバイアスベクトル(形状:(4, state_size,))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = lstm_cell(<args>)
- class nnabla.parametric_functions.LSTMCell(batch_size, state_size, h=None, c=None, name=None)[ソース]
- __call__(x, w_init, b_init, fix_parameters)[ソース]
lstm 関数を呼び出して h と c を更新します。
- パラメータ:
x (Variable) -- Input N-D array with shape (batch_size, input_size).
w_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- 重みのイニシャライザー。デフォルトでは、nnabla.initializer.calc_uniform_lim_glorotによって決定される範囲内でnnabla.initializer.UniformInitializerで初期化されます。b_init (
nnabla.initializer.BaseInitializerornumpy.ndarray, optional) -- バイアスのイニシャライザー。with_biasがTrueの場合、デフォルトではゼロで初期化されます。
- nnabla.parametric_functions.spectral_norm(w, dim=0, itr=1, eps=1e-12, test=False, u_init=None, fix_parameters=True, name=None)[ソース]
Spectral Normalization (スペクトル正規化)
\[W_{sn} = \frac{W}{\sigma(W)}.\]ここで、 \(W\) は入力の行列であり、 \(\sigma(W)\) は \(W\) のスペクトルノルムです。スペクトルノルムは、パワーイテレーションによって近似的に計算されます。
参照
Takeru Miyato, Toshiki Kataoka, Masanori Koyama, Yuichi Yoshida, "Spectral Normalization for Generative Adversarial Networks", International Conference on Learning Representations. 2018.
- パラメータ:
- 戻り値:
\(W\) と同じ形状のスペクトル正規化された \(W_{sn}\)
- 戻り値の型:
サンプル
import nnabla as nn import nnabla.parametric_functions as PF b, c, h, w = 4, 64, 32, 32 # Spectrally normalized convolution apply_w = lambda w: PF.spectral_norm(w, dim=0) h = nn.Variable.from_numpy_array(np.random.randn(b, c, h, w)) h = PF.convolution(h, with_bias=False, apply_w=apply_w) # Spectrally normalized affine apply_w = lambda w: PF.spectral_norm(w, dim=1) h = nn.Variable.from_numpy_array(np.random.randn(b, c)) h = PF.affine(h, with_bias=False, apply_w=apply_w) # Spectrally normalized embed apply_w = lambda w: PF.spectral_norm(w, dim=1) h = nn.Variable.from_numpy_array(np.random.randn(b, c)) h = PF.embed(h, c, apply_w=apply_w)
- 登録されるパラメータ
次の変数は、パラメータスコープ
"spectral-norm"に登録されています。u (
need_grad=False) : 特異ベクトル (形状:(w.shape[dim], ))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = spectral_norm(<args>)
- nnabla.parametric_functions.weight_normalization(w, dim=0, eps=1e-12, g_init=None, fix_parameters=False, name=None)[ソース]
Weight Normalization
\[\mathbf{w}_{WN} = g \dfrac{\mathbf{w}}{\|\mathbf{w}\|}\]where \(\mathbf{w}\) is the input weights to be normalized, and \(g\) is learnable multiplication factors each of which is applied to each input weights at
dim. This function is in general used as callback passed to apply_w for PF.convolution, PF.affine and so on. According to the author`s original implementation, \(v\) should be initialized by \(N(0, 0.05)\). To meet this condition, initializer should be passed to convolution which Weight Normalization is applied, like an example below.参照
- パラメータ:
W (Variable) -- 形状の入力 N-D 配列。これは通常ネットワークのパラメータです。
dim (
int) -- 出力次元。デフォルトは 0 です。次元が 0 でない場合、指定された次元は転置によって左端の次元になります。eps (
float) -- 正規化の際に用いられるイプシロン。デフォルトは 1e-12 です。g_init (
nnabla.initializer.BaseInitializerornumpy.ndarray) -- Initializer for the scale. By default, L2-norm of weights corresponding todimare used.
- 戻り値:
\(W\) with the same shape as \(v\).
- 戻り値の型:
サンプル
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I # h is nn.Variable. # convolution # according to the original implementation, w should be initialized by N(0, 0.05). h = PF.convolution(h, ..., apply_w=PF.weight_normalization, w_init=I.NormalInitializer(0.05)) # affine h = PF.affine(h, ..., apply_w=lambda w: PF.weight_normalization(w, dim=1), w_init=I.NormalInitializer(0.05))
警告
Up to the version 1.10.0, this had been implemented as the composite functions.
- 登録されるパラメータ
次の変数は、パラメータスコープ
"wn"に登録されます。g (
need_grad=True) : Weight Normalization 適応スケールスカラー。 (形状:w.shape[dim])
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = weight_normalization(<args>)
- nnabla.parametric_functions.multi_head_attention(query, key, value, num_heads=12, dropout=0.0, k_embed_dim=None, v_embed_dim=None, out_dim=None, rng=None, with_bias=True, add_attn_bias=False, additive_mask=None, key_padding_mask=None, fix_parameters=False, param_init=None, name=None)[ソース]
MultiHeadAttention
Computes multi-headed attention with query, key, and value. We use the following notations to describe the inputs and outputs below. \(L_T\): target sequence length, \(L_S\): source sequence length, \(B\): batch size, \(D\): input dimension, \(E\): embedding dimension.
参照
A. Vaswani et al. "Attention is All You Need." NIPS. 2017. <https://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf>
例：
q = nn.Variable((tgt_len, batch_size, q_input_dim)) k = nn.Variable((src_len, batch_size, k_input_dim)) v = nn.Variable((src_len, batch_size, v_input_dim)) out, w = PF.multi_head_attention(q, k, v) out.forward()
- パラメータ:
query (Variable) -- Input N-D array with shape \((L_T, B, D_q)\).
key (Variable) -- Input N-D array with shape \((L_S, B, D_k)\).
value (Variable) -- Input N-D array with shape \((L_S, B, D_v)\).
num_heads (int, optional) -- attention head の数。次元 E の埋め込みは、head の数で割り切れる必要があることに注意してください。デフォルトはよく用いられる12です。
dropout (float, optional) -- パラメータに適用されるドロップアウト比。デフォルトは 0 です。
k_embed_dim (int, optional) -- Embedding dimension for key. If specified, embedding dimensions for both query and key are set as that value. Otherwise, k_embed_dim is set as the same alue as embedding dimension for query.
v_embed_dim (int, optional) -- Embedding dimension for value. If not specified, it is defaulted as the same value as embedding dimension for query.
out_dim (int, optional) -- Embedding dimension for output weight. If not spefied, it is defaulted as the same value as embedding dimension for value.
rng (numpy.random.RandomState, optional) -- イニシャライザーのランダムジェネレーター。デフォルトは None です。
with_bias (bool, optional) -- バイアス項を含めるか否かを指定します。 デフォルトは True です。
add_attn_bias (bool, optional) -- キーと値に attention バイアスパラメータを追加するか否かを指定します。デフォルトは False です。
additive_mask (Variable, optional) -- \((L_T, L_S)\) の形状の入力 N-D 配列。 特定の位置への attention を防ぐために、attention 層に値が追加されます。
key_padding_mask (Variable, optional) -- \((B, L_S)\) の形状の入力 N-D 配列。指定されたパディング要素は attention 層によって無視されます。値は 1 または 0 である必要があります。
fix_parameters (bool, optional) --
Trueに設定すると、重みとバイアスは更新されません。デフォルトは False です。param_init (dict, optional) -- パラメータイニシャライザーは dict で設定できます。dict の設定可能なキーには、q_weight、k_weight、v_weight、q_bias、k_bias、v_bias、out_weight、out_bias、attn_bias_k、attn_bias_v があります。dict の値は、
Initializerまたはnumpy.ndarrayである必要がります。例{'q_bias': ConstantInitializer(0)}。
- 戻り値:
\((L_T, B, E)\) の形状をもつ出力 \(y\) ~nnabla.Variable: \((B, L_T, L_S)\) の形状をもつ出力 \(h_n\)
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"multi_head_attention"に登録されます。q_weight (
need_grad=True) : クエリの重み (形状:(E, E))k_weight (
need_grad=True) : キーの重み (形状:(E_k, E))v_weight (
need_grad=True) : 値の重み (形状:(E_v, E))out_weight (
need_grad=True) : 射影の重み (形状:(E, E))q_bias (
need_grad=True) : クエリのバイアス (形状:(E, ))k_bias (
need_grad=True) : キーのバイアス (形状:(E, ))v_bias (
need_grad=True) : 値のバイアス (形状:(E, ))out_bias (
need_grad=True) : 射影のバイアス (形状:(E, ))attn_bias_k (
need_grad=True) : k のattention バイアス (形状:(E, 1))attn_bias_v (
need_grad=True) : v の attention バイアス (形状:(E, 1))
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = multi_head_attention(<args>)
- nnabla.parametric_functions.transformer(src, tgt, embed_dim=512, num_heads=8, num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048, dropout=0.1, activation=None, src_additive_mask=None, tgt_additive_mask=None, memory_additive_mask=None, src_key_padding_mask=None, tgt_key_padding_mask=None, memory_key_padding_mask=None, rng=None, add_attn_bias=False, fix_parameters=False, name=None)[ソース]
Transformer (トランスフォーマー)
以下では入力と出力を説明するために、次の表記を使用します。 \(L_T\) ：ターゲットシーケンスの長さ、 \(L_S\) ：ソースシーケンスの長さ、 \(B\) ：バッチサイズ、 \(E\) ：埋め込み次元。
参照
A. Vaswani et al. "Attention is All You Need." NIPS. 2017. <https://papers.nips.cc/paper/7181-attention-is-all-you-need.pdf>
例：
src = nn.Variable((src_len, batch_size, embed_dim),need_grad=True) tgt = nn.Variable((tgt_len, batch_size, embed_dim),need_grad=True) out = PF.transformer(src, tgt, num_heads=16, num_encoder_layers=12) out.forward()
- パラメータ:
src (Variable) -- \((L_S, B, E)\) の形状のエンコーダーへの入力ソースシーケンス。
tgt (Variable) -- \((L_T, B, E)\) の形状のデコーダーへの入力ターゲットシーケンス。
embed_dim (int, optional) -- 使用する埋め込み次元。デフォルトは 512 です。
num_heads (int, optional) -- attention head の数。デフォルトは 12 です。
num_encoder_layers (int, optional) -- 使用するエンコーダー層数。デフォルトは 6 です。
num_decoder_layers (int, optional) -- 使用するデコーダー層数。デフォルトは 6 です。
dim_feedforward (int, optional) -- feedforward ネットワークモデルの次元。デフォルトは 2048 です。
dropout (float, optional) -- 適用されるドロップアウト率。デフォルトは 0.1 です。
activation (function, optional) -- 使用する非線形活性化関数。デフォルトは None で、その場合F.relu が使用されます。
src_additive_mask (Variable, optional) -- src シーケンスの追加マスク (オプション). \((L_S, L_S)\)
tgt_additive_mask (Variable, optional) -- Additive mask for the tgt sequence (optional). \((L_T, L_T)\).
memory_additive_mask (Variable, optional) -- エンコーダー出力の追加マスク (オプション). \((L_T, L_S)\)
src_key_padding_mask (Variable, optional) -- Key padding mask for src keys per batch (optional). \((B, L_S)\). Specified padding elements will be ignored by the attention layer. Values must be either 1 or 0.
tgt_key_padding_mask (Variable, optional) -- Key padding mask for tgt keys per batch (optional). \((B, L_T)\). Specified padding elements will be ignored by the attention layer. Values must be either 1 or 0.
memory_key_padding_mask (Variable, optional) -- Key padding mask for memory keys per batch (optional). \((B, L_S)\). Specified padding elements will be ignored by the attention layer. Values must be either 1 or 0.
rng (numpy.random.RandomState, optional) -- イニシャライザーのランダムジェネレーター。デフォルトは None です。
add_attn_bias (bool, optional) -- キーと値に attention バイアスパラメータを追加するか否かを指定します。デフォルトは False です。
fix_parameters (bool, optional) --
Trueに設定すると、重みとバイアスは更新されません。デフォルトは False です。
- 戻り値:
形状 \((L_T, B, E)\) の出力 \(y\)
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"transformer"に登録されます。encoder{layer#} (
need_grad=True) : n 番目のエンコーダー層のパラメータ (形状:Refer to transformer_encode for details)decoder{layer#} (
need_grad=True) : n 番目のデコーダー層のパラメータ (形状:詳細については transformer_decodeを参照してください)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = transformer(<args>)
- nnabla.parametric_functions.transformer_encode(src, embed_dim, num_heads, dim_feedforward=2048, dropout=0.1, activation=None, src_additive_mask=None, src_key_padding_mask=None, rng=None, add_attn_bias=False, fix_parameters=False, name=None)[ソース]
Transformer Encoder (トランスフォーマーエンコーダー)
- パラメータ:
src (Variable) -- \((L_S, B, E)\) の形状のエンコーダー層への入力シーケンス。
embed_dim (int) -- 埋め込み次元の数。
num_heads (int) -- attention head の数。
dim_feedforward (int, optional) -- feedforward ネットワークモデルの次元。デフォルトは 2048 です。
dropout (float, optional) -- ドロップアウト率。デフォルトは 0.1 です。
activation (function, optional) -- 使用する非線形活性化関数。デフォルトは None で、その場合F.relu が使用されます。
src_additive_mask (Variable, optional) -- 形状 \((L_S, L_S)\) のソースシーケンスの追加マスク
src_key_padding_mask (Variable, optional) -- \((B, L_S)\) の形状のソースシーケンスのパディングマスク 。指定されたパディング要素は attention 層によって無視されます。値は 1 または 0 である必要があります。
rng (numpy.random.RandomState, optional) -- イニシャライザーのランダムジェネレーター。デフォルトは None です。
add_attn_bias (bool, optional) -- キーと値に attention バイアスパラメータを追加するか否かを指定します。デフォルトは False です。
fix_parameters (bool, optional) --
Trueに設定すると、重みとバイアスは更新されません。デフォルトは False です。
- 戻り値:
形状 \((L_S, B, E)\) の出力 \(y\)
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"transformer_encode"に登録されます。src_self_attn (
need_grad=True) : ソースシーケンスの self-attention パラメータ(形状:詳細については multi_head_attention を参照してください)enc_affine1 (
need_grad=True) : エンコーダーで使用される最初の Affine (形状:詳細については affine を参照してください)enc_affine2 (
need_grad=True) : エンコーダーで使用される 2 番目の Affine (形状:詳細については affine を参照してください)enc_layer_norm1 (
need_grad=True) : エンコーダーで使用される最初の layer normalization (形状:詳細については layer_normalization を参照してください)enc_layer_norm2 (
need_grad=True) : エンコーダーで使用される 2 番目の layer normalization (形状:詳細については layer_normalization を参照してください)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = transformer_encode(<args>)
- nnabla.parametric_functions.transformer_decode(tgt, memory, embed_dim, num_heads, dim_feedforward=2048, dropout=0.1, activation=None, tgt_additive_mask=None, memory_additive_mask=None, tgt_key_padding_mask=None, memory_key_padding_mask=None, rng=None, add_attn_bias=False, fix_parameters=False, name=None)[ソース]
Transformer Decoder (トランスフォーマーデコーダー)
- パラメータ:
tgt (Variable) -- \((L_T, B, E)\) の形状のデコーダー層への入力シーケンス。
memory (Variable) -- \((L_T, B, E)\) の形状のエンコーダーの最後の層からの出力シーケンス。
embed_dim (int) -- 埋め込み次元の数。
num_heads (int) -- attention head の数。
dim_feedforward (int, optional) -- feedforward ネットワークモデルの次元。デフォルトは 2048 です。
dropout (float, optional) -- ドロップアウト率。デフォルトは 0.1 です。
activation (function, optional) -- 使用する非線形活性化関数。デフォルトは None で、その場合F.relu が使用されます。
tgt_additive_mask (Variable, optional) -- \((L_T, L_T)\) の形状のターゲットシーケンスの追加マスク。
memory_additive_mask (Variable, optional) -- \((L_T, L_S)\) の形状のメモリシーケンスの追加マスク。
tgt_key_padding_mask (Variable, optional) -- \((B, L_T)\) の形状のターゲットシーケンスのパディングマスク。指定されたパディング要素は、attention 層によって無視されます。値は 1 または 0 である必要があります。
memory_key_padding_mask (Variable, optional) -- \((B, L_S)\) の形状のマスクシーケンスのパディングマスク。指定されたパディング要素は、attention 層によって無視されます。値は 1 または 0 である必要があります。
rng (numpy.random.RandomState) -- イニシャライザーのランダムジェネレーター。デフォルトは None です。
add_attn_bias (bool, optional) -- キーと値に attention バイアスパラメータを追加するか否かを指定します。デフォルトは False です。
fix_parameters (bool) --
Trueに設定すると、重みとバイアスは更新されません。デフォルトは False です。
- 戻り値:
形状 \((L_T, B, E)\) の出力 \(y\)
- 戻り値の型:
- 登録されるパラメータ
次の変数は、パラメータスコープ
"transformer_decode"に登録されます。tgt_self_attn (
need_grad=True) : ターゲットシーケンスの self-attention パラメータ(形状:詳細については multi_head_attention を参照してください)tgt_memory_attn (
need_grad=True) : エンコーダーからの出力をキーとするターゲットシーケンスの attention パラメータ (形状:詳細については multi_head_attention for details を参照してください)dec_affine1 (
need_grad=True) : デコーダーで使用される最初の Affine (形状:詳細については affine を参照してください)dec_affine2 (
need_grad=True) : デコーダーで使用される 2 番目の Affine (形状:詳細については affine を参照してください)dec_layer_norm1 (
need_grad=True) : デコーダーで使用される最初の layer normalization (形状:詳細については layer_normalization を参照してください)dec_layer_norm2 (
need_grad=True) : デコーダーで使用される 2 番目の layer normalization (形状:詳細については layer_normalization を参照してください)dec_layer_norm3 (
need_grad=True) : デコーダーで使用される 3 番目の layer normalization (形状:詳細については layer_normalization を参照してください)
注釈
nameオプションが渡された場合、パラメータは特定の名前でパラメータスコープ内にラップされ、以下のコードと同じ結果となります。これは、コードの簡素化に利用できます。with parameter_scope(name): output = transformer_decode(<args>)
パラメータイニシャライザー
一部のパラメトリック関数は、オプションで以下のパラメータイニシャライザーを使用することができます。
- class nnabla.initializer.BaseInitializer[ソース]
パラメータイニシャライザーのベースクラス
- __call__(shape)[ソース]
イニシャライザーで配列を生成します。
- パラメータ:
shape (
tupleofint) -- 生成された形状のnumpy.ndarray。- 戻り値:
配列
- 戻り値の型:
注釈
BaseInitializerのサブクラスはこのメソッドをオーバーライドする必要があります。
- class nnabla.initializer.ConstantInitializer(value=0)[ソース]
ベースクラス:
BaseInitializer定数値で構成される配列を生成します。
- パラメータ:
value (float) -- 定数値。
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) w = I.ConstantInitializer(0.1) b = I.ConstantInitializer() # this generates constant valued array of default value 0 h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv'
- class nnabla.initializer.NormalInitializer(sigma=1.0, rng=None)[ソース]
ベースクラス:
BaseInitializer指定された正規分布からランダム配列を生成します。
\[\mathbf x \sim {\cal N} (\mathbf 0 | \sigma^2 \mathbf I)\]- パラメータ:
sigma (float) -- \(\sigma\).
rng (numpy.random.RandomState) -- 乱数ジェネレーター。
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) w = I.NormalInitializer(5e-5) b = I.NormalInitializer(0.0) h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv')
- class nnabla.initializer.UniformInitializer(lim=(-1, 1), rng=None)[ソース]
ベースクラス:
BaseInitializer指定された均一分布からランダム配列を生成します。
\[\mathbf x \sim {\cal U} (a, b)\]- パラメータ:
rng (numpy.random.RandomState) -- 乱数ジェネレーター。
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) w = I.UniformInitializer() # this generates uniform distribution within the default range of (-1,1) b = I.UniformInitializer((-0.5,0.5)) h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv')
- class nnabla.initializer.UniformIntInitializer(lim=(0, 10), rng=None)[ソース]
ベースクラス:
BaseInitializer指定された整数均一分布からランダム配列を生成します。
\[\mathbf x \sim {\cal U} ([a, b))\]- パラメータ:
rng (numpy.random.RandomState) -- 乱数ジェネレーター。
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) w = I.UniformIntInitializer() # this generates uniform integer distribution within the default range of (0,10) b = I.UniformIntInitializer((-1,1)) h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv')
- class nnabla.initializer.RangeInitializer(start=0, step=1)[ソース]
ベースクラス:
BaseInitializer数値のシーケンスをもつ配列を生成します。
\[\mathbf x[i] = start + step * i\]例：
import nnabla as nn import nnabla.initializer as I x = nn.Variable([100]) x.d = I.RangeInitializer(0, 1)(x.shape)
- class nnabla.initializer.OrthogonalInitializer(gain=1.0, rng=None)[ソース]
ベースクラス:
BaseInitializerSaxe らによって提案された直交行列の重みを生成します。
- パラメータ:
gain (float) -- 単位タイプに応じて決定する必要があるスケーリングファクター。
rng (numpy.random.RandomState) -- 乱数ジェネレーター。
例：
import numpy as np import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) w = I.OrthogonalInitializer(np.sqrt(2.0)) b = I.ConstantInitializer(0.0) h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv')
参照
- class nnabla.initializer.WeightNormalizationScaleInitializer(w, dim=0, eps=1e-12)[ソース]
ベースクラス:
BaseInitializerCompute the L2-norm for each weight kernel.
This initializer is specific to the weight normalization scale to keep the same magnitude of the originally initialized weights even after the application of the weight normalization at only initialization.
- nnabla.initializer.calc_normal_std_he_forward(inmaps, outmaps, kernel=(1, 1))[ソース]
He らによって提案された標準偏差を計算します。
\[\sigma = \sqrt{\frac{2}{NK}}\]- パラメータ:
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) s = I.calc_normal_std_he_forward(x.shape[1],64) w = I.NormalInitializer(s) b = I.ConstantInitializer(0) h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv')
参照
- nnabla.initializer.calc_normal_std_he_backward(inmaps, outmaps, kernel=(1, 1))[ソース]
He らにより提案された標準偏差を計算します (backward の場合)。
\[\sigma = \sqrt{\frac{2}{MK}}\]- パラメータ:
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) s = I.calc_normal_std_he_backward(x.shape[1],64) w = I.NormalInitializer(s) b = I.ConstantInitializer(0) h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv')
参照
- nnabla.initializer.calc_normal_std_glorot(inmaps, outmaps, kernel=(1, 1))[ソース]
Glorot らによって提案された標準偏差を計算します。
注釈
v.1.2 から以下のように定義を更新しました。デフォルトの初期化を用いている既存のスクリプトの動作に影響を与える可能性があります。
\[\sigma = \sqrt{\frac{2}{K(N + M)}}\]- パラメータ:
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) s = I.calc_normal_std_glorot(x.shape[1],64) w = I.NormalInitializer(s) b = I.ConstantInitializer(0) h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv')
参照
- nnabla.initializer.calc_uniform_lim_glorot(inmaps, outmaps, kernel=(1, 1))[ソース]
Glorot らによって提案された均一分布の下限と上限を計算します。
注釈
v.1.3 から以下のように定義を更新しました。デフォルトの初期化を用いている既存のスクリプトの動作に影響を与える可能性があります。
\[\begin{split}b &= \sqrt{\frac{6}{K(N + M)}}\\ a &= -b\end{split}\]- パラメータ:
例：
import nnabla as nn import nnabla.parametric_functions as PF import nnabla.initializer as I x = nn.Variable([60,1,28,28]) lb,ub= I.calc_uniform_lim_glorot(x.shape[1],64) w = I.UniformInitializer((lb,ub)) b = I.ConstantInitializer(0) h = PF.convolution(x, 64, [3, 3], w_init=w, b_init=b, pad=[1, 1], name='conv')
参照