ホーム » 「TensorLayer」タグがついた投稿

タグアーカイブ: TensorLayer

TensorFlow : TensorLayer : FAQ

TensorFlow : TensorLayer : FAQ (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 12/06/2018

* 本ページは、TensorLayer の以下のドキュメントの一部を翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

FAQ

TensorLayer をどのように効果的に学習するか

貴方がどのステージにいようとも、TensorLayer のソースコードとこの web サイト の Understand layer / Your layer を読むためにちょうど 10 分を費やすことを勧めます、抽象的な方法が誰に取っても非常に単純であることを見い出すでしょう。ソースコードを読むことは TensorFlow をより良く理解する助けとなりそして貴方自身のメソッドを容易に実装することを可能にします。

 

初心者

深層学習が初めてである人に対しては、contirbutors がこの web サイトで多くのチュートリアルを提供しています、これらのチュートリアルはオートエンコーダ、畳込みニューラルネットワーク、リカレント・ニューラルネットワーク、単語埋め込みと深層強化学習等を理解する案内をするでしょう。貴方が深層学習の基本を既に理解している場合には、チュートリアルはスキップして GitHub 上のサンプルコードを読み、スクラッチからサンプルを実装することを勧めます。

 

技術者

産業からの人々のために、contributors は多くの形式が一貫したサンプルを提供しました、コンピュータ・ビジョン、自然言語処理、そして強化学習をカバーしています。加えて、(オンラインで見つけられる) 画像キャプショニング、セマンティック/インスタンス・セグメンテーション、機械翻訳、チャットボット等の製品レベルのサンプルを既に実装した多くの TensorFlow ユーザもいます。注目すべき点は、特にコンピュータ・ビジョンのためのラッパー Tf-Slim は TensorLayer とシームレスに接続可能であることです。従って、貴方のプロジェクトで使用可能なサンプルを見つけることができるかもしれません。

 

研究者

学術からの人々のために、TensorLayer は元々は新規のアルゴリズムを実装する際に他のライブラリに伴う問題に直面した PhD 学生により開発されました。編集可能なモードで TensorLayer をインストールすることが推奨されます、そうすれば TensorLayer で貴方のメソッドを拡張できます。画像キャプショニング、ビジュアル QA 等のような画像関連の研究者のために、TensorLayer で既存の Tf-Slim 事前訓練モデルを使用することは非常に有用であることを見い出すかもしれません (Tf-Slim と接続するための特別な層が提供されます)。

 

幾つかの層を訓練から除外する

更新することを望む変数のリストを得る必要があるかもしれません、TensorLayer は変数リストを得るための 2 つの方法を提供します。

最初の方法はネットワークの all_params を使用することです、デフォルトでは、それは変数を順番にストアします。tl.layers.print_all_variables(train_only=True) あるいは network.print_params(details=False) を通して変数情報を表示出力できます。どの変数を更新するか選択するために、下を行なうことができます。

train_params = network.all_params[3:]

2 番目の方法は与えられた名前で変数を取得します。例えば、層名が dense を含む総ての変数を得たい場合には、下のようにできます。

train_params = tl.layers.get_variables_with_name('dense', train_only=True, printable=True)

変数リストを得る後、変数の一部だけを更新するように次のように optimizer を定義できます。

train_op = tf.train.AdamOptimizer(0.001).minimize(cost, var_list= train_params)

 

Logging

TensorLayer は実行情報をログするために Python logging module を採用しています。logging モジュールはデフォルトではコンソールにログを表示出力します。logging モジュールを configure することを望む場合、その マニュアル に従ってください。

 

可視化

Cannot Save Image

SSH 制御を通してスクリプトを実行する場合、時々次のエラーを見つけるかもしれません。

_tkinter.TclError: no display name and no $DISPLAY environment variable

それが発生する場合、sudo apt-get install python3-tk を実行するか、import tensorlayer as tl の前に import matplotlib そして matplotlib.use(‘Agg’) してください。代替的に、visualize.py か貴方自身のコードのトップに次のコードを追加してください。

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

 

マスター・バージョンをインストールする

TensorLayer の総ての新しい特徴を使用するためには、Github から新しいバージョンをインストールする必要があります。その前に、既に git をインストールしていることを確実にする必要があります。

[stable version] pip install tensorlayer
[master version] pip install git+https://github.com/tensorlayer/tensorlayer.git

 

モデルをロードする

tl.files.load_npz() は tl.files.save_npz() によりセーブされた npz モデルだけをロードできることに注意してください。TensorLayer ネットワークにロードしたいモデルを持つ場合、最初にパラメータを順番にリストに割り当てて、それからパラメータを貴方の TensorLayer モデルにロードするために tl.files.assign_params() を使用することができます。

 

以上






TensorFlow : TensorLayer : チュートリアル (5) 言語モデル (LSTM)

TensorFlow : TensorLayer : チュートリアル (5) (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 12/06/2018

* 本ページは、TensorLayer の以下のドキュメントの一部を翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

チュートリアル (5)

PTB サンプルを実行する

Penn TreeBank (PTB) データセットは “Empirical Evaluation and Combination of Advanced Language Modeling Techniques”, “Recurrent Neural Network Regularization” を含む、多くの 言語モデリング ペーパーで使用されています。それは 929k 訓練単語、73k 検証単語そして 82k テスト単語から成ります。それはその語彙に 10k 単語を持ちます。

PTB サンプルは言語モデリングの挑戦タスク上でリカレント・ニューラルネットワークをどのように訓練するかを示すことを試行します。

センテンス “I am from Imperial College London” が与えられたとき、モデルは “from Imperial College” から “Imperial College London” を予測することを学習できます。換言すれば、それは前の単語の履歴が与えられたときテキストの次の単語を予測します。前の例では、num_steps (シークエンス長) は 3 です。

python tutorial_ptb_lstm.py

スクリプトは 3 つの設定 (small, medium, large) を提供します、そこではより大きなモデルはより良いパフォーマンスを持ちます。次で異なる設定を選択できます :

flags.DEFINE_string(
    "model", "small",
    "A type of model. Possible options are: small, medium, large.")

small 設定を選択する場合、以下を見ることができます :

Epoch: 1 Learning rate: 1.000
0.004 perplexity: 5220.213 speed: 7635 wps
0.104 perplexity: 828.871 speed: 8469 wps
0.204 perplexity: 614.071 speed: 8839 wps
0.304 perplexity: 495.485 speed: 8889 wps
0.404 perplexity: 427.381 speed: 8940 wps
0.504 perplexity: 383.063 speed: 8920 wps
0.604 perplexity: 345.135 speed: 8920 wps
0.703 perplexity: 319.263 speed: 8949 wps
0.803 perplexity: 298.774 speed: 8975 wps
0.903 perplexity: 279.817 speed: 8986 wps
Epoch: 1 Train Perplexity: 265.558
Epoch: 1 Valid Perplexity: 178.436
...
Epoch: 13 Learning rate: 0.004
0.004 perplexity: 56.122 speed: 8594 wps
0.104 perplexity: 40.793 speed: 9186 wps
0.204 perplexity: 44.527 speed: 9117 wps
0.304 perplexity: 42.668 speed: 9214 wps
0.404 perplexity: 41.943 speed: 9269 wps
0.504 perplexity: 41.286 speed: 9271 wps
0.604 perplexity: 39.989 speed: 9244 wps
0.703 perplexity: 39.403 speed: 9236 wps
0.803 perplexity: 38.742 speed: 9229 wps
0.903 perplexity: 37.430 speed: 9240 wps
Epoch: 13 Train Perplexity: 36.643
Epoch: 13 Valid Perplexity: 121.475
Test Perplexity: 116.716

PTB サンプルは RNN が言語をモデル化できることを示しますが、このサンプルは何か実践的に興味深いことは行ないませんでした。けれども貴方は RNN の基本を理解するためにこの例と “Understand LSTM” を読み通すべきです。その後で、RNN を使用することによってテキストをどのように生成するか、言語翻訳をどのように達成するか、そして質問応答システムをどのように構築するかを学習するでしょう。

 

LSTM を理解する

リカレント・ニューラルネットワーク

個人的にはリカレント・ニューラルネットワークを理解するためには Andrej Karpathy のブログ が最善の資料と考えます、それを読んだ後、Colah のブログ が (長期依存性の問題を解くことができる) LSTM ネットワークを理解する助けとなれます。RNN の理論についてはこれ以上記述しませんので、進む前にこれらのブログを通して読んでください。

Image by Andrej Karpathy

 

同期したシークエンス入力と出力

PTB サンプルのモデルは同期したシークエンス入力と出力の典型的なタイプです、これは Karpathy により次のように記述されていました: “(5) Synced sequence input and output (e.g. ビデオの各フレームにラベル付けることを望むビデオ分類)。総てのケースでシークエンスの長さについて事前指定された制約がないことに注意してください、何故ならばリカレント変換 (green) は好きなだけの回数適用可能であるからです。”

モデルは次のように構築されます。最初に、埋め込み行列を検索することにより単語を単語ベクトルに移します。このチュートリアルでは、埋め込み行列上での事前訓練はありません。2 番目に、埋め込み層、LSTM 層(s) そして正則化のための出力層の間で dropout を使用して、2 つの LSTM を一緒にスタックします。最後の層では、モデルは softmax 出力のシークエンスを提供します。

最初の LSTM 層はその後でもう一つの LSTM をスタックするために [batch_size, num_steps, hidden_size] を出力します。2 番目の LSTM 層はその後で DenseLayer をスタックするために [batch_size*num_steps, hidden_size] を出力します。それから DenseLayer は各サンプル (n_examples = batch_size*num_steps) の softmax 出力を計算します。

PTB チュートリアルを理解するためには、TensorFlow PTB チュートリアル も読むことができます。

(TensorLayer は v1.1の後 DynamicRNNLayer をサポートしますので、一つの単一層で入力/出力 dropout、幾つかの RNN 層を設定できます。)

network = tl.layers.EmbeddingInputlayer(
            inputs = x,
            vocabulary_size = vocab_size,
            embedding_size = hidden_size,
            E_init = tf.random_uniform_initializer(-init_scale, init_scale),
            name ='embedding_layer')
if is_training:
    network = tl.layers.DropoutLayer(network, keep=keep_prob, name='drop1')
network = tl.layers.RNNLayer(network,
            cell_fn=tf.contrib.rnn.BasicLSTMCell,
            cell_init_args={'forget_bias': 0.0},
            n_hidden=hidden_size,
            initializer=tf.random_uniform_initializer(-init_scale, init_scale),
            n_steps=num_steps,
            return_last=False,
            name='basic_lstm_layer1')
lstm1 = network
if is_training:
    network = tl.layers.DropoutLayer(network, keep=keep_prob, name='drop2')
network = tl.layers.RNNLayer(network,
            cell_fn=tf.contrib.rnn.BasicLSTMCell,
            cell_init_args={'forget_bias': 0.0},
            n_hidden=hidden_size,
            initializer=tf.random_uniform_initializer(-init_scale, init_scale),
            n_steps=num_steps,
            return_last=False,
            return_seq_2d=True,
            name='basic_lstm_layer2')
lstm2 = network
if is_training:
    network = tl.layers.DropoutLayer(network, keep=keep_prob, name='drop3')
network = tl.layers.DenseLayer(network,
            n_units=vocab_size,
            W_init=tf.random_uniform_initializer(-init_scale, init_scale),
            b_init=tf.random_uniform_initializer(-init_scale, init_scale),
            act = tf.identity, name='output_layer')

 

データセット反復

batch_size は実行している同時の計算の数として見ることができます。次のサンプルが示すように、最初のバッチは項目 0 から 9 使用してシークエンス情報を学習します。2 番目のバッチは項目 10 から 19 を使用してシークエンス情報を学習します。従ってそれは項目 9 から 10 への情報は無視します。batch_size = 1 を設定する場合に限り、それは項目 0 から 20 への総ての情報を考慮します。

ここでは batch_size の意味は MNIST サンプルにおける batch_size と同じではありません。MNIST サンプルでは、batch_size は各反復で幾つのサンプルを考慮するかを反映しますが、一方で PTB サンプルでは、batch_size は計算を加速するための同時プロセス (セグメント) の数です。batch_size > 1 であればある情報は無視されます、けれども貴方のデータセットが十分に「長い」(テキスト・コーパスは通常は数十億の単語を持ちます) のであれば、無視された情報は最終結果に影響しないでしょう。

PTB チュートリアルでは、batch_size = 20 を設定しますので、データセットを 20 セグメントに分割します。各エポックの最初に、20 セグメントのための 20 RNN 状態をゼロに初期化 (リセット) し、それから 20 セグメントを別々に通り抜けます。

訓練データを生成する例は次のようなものです :

train_data = [i for i in range(20)]
for batch in tl.iterate.ptb_iterator(train_data, batch_size=2, num_steps=3):
    x, y = batch
    print(x, '\n',y)
... [[ 0  1  2] <---x                       1st subset/ iteration
...  [10 11 12]]
... [[ 1  2  3] <---y
...  [11 12 13]]
...
... [[ 3  4  5]  <--- 1st batch input       2nd subset/ iteration
...  [13 14 15]] <--- 2nd batch input
... [[ 4  5  6]  <--- 1st batch target
...  [14 15 16]] <--- 2nd batch target
...
... [[ 6  7  8]                             3rd subset/ iteration
...  [16 17 18]]
... [[ 7  8  9]
...  [17 18 19]]

Note: このサンプルは単語埋め込み行列の事前訓練としても考えることができます。

 

損失と更新式

コスト関数は各ミニバッチの平均コストです :

nsorlayer.cost.cross_entropy_seq() for more details
def loss_fn(outputs, targets, batch_size, num_steps):
    # Returns the cost function of Cross-entropy of two sequences, implement
    # softmax internally.
    # outputs : 2D tensor [batch_size*num_steps, n_units of output layer]
    # targets : 2D tensor [batch_size, num_steps], need to be reshaped.
    # n_examples = batch_size * num_steps
    # so
    # cost is the average cost of each mini-batch (concurrent process).
    loss = tf.nn.seq2seq.sequence_loss_by_example(
        [outputs],
        [tf.reshape(targets, [-1])],
        [tf.ones([batch_size * num_steps])])
    cost = tf.reduce_sum(loss) / batch_size
    return cost

# Cost for Training
cost = loss_fn(network.outputs, targets, batch_size, num_steps)

更新については、学習プロセスを扱いやすくするために、truncated backpropagation が勾配の値をそれらのノルムの総計の比率によりクリップします。

# Truncated Backpropagation for training
with tf.variable_scope('learning_rate'):
    lr = tf.Variable(0.0, trainable=False)
tvars = tf.trainable_variables()
grads, _ = tf.clip_by_global_norm(tf.gradients(cost, tvars),
                                  max_grad_norm)
optimizer = tf.train.GradientDescentOptimizer(lr)
train_op = optimizer.apply_gradients(zip(grads, tvars))

加えて、エポックインデックスが max_epoch よりも大きい場合には、学習率を lr_decay を乗算することにより減少させます。

new_lr_decay = lr_decay ** max(i - max_epoch, 0.0)
sess.run(tf.assign(lr, learning_rate * new_lr_decay))

各エポックの最初に、LSTM の総ての状態はゼロ状態にリセット (初期化) される必要があります。それから各反復後、LSTM の状態は更新され、そこで新しい LSTM 状態 (最終状態) は次の反復の初期状態として割り当てられる必要があります :

# set all states to zero states at the beginning of each epoch
state1 = tl.layers.initialize_rnn_state(lstm1.initial_state)
state2 = tl.layers.initialize_rnn_state(lstm2.initial_state)
for step, (x, y) in enumerate(tl.iterate.ptb_iterator(train_data,
                                            batch_size, num_steps)):
    feed_dict = {input_data: x, targets: y,
                lstm1.initial_state: state1,
                lstm2.initial_state: state2,
                }
    # For training, enable dropout
    feed_dict.update( network.all_drop )
    # use the new states as the initial state of next iteration
    _cost, state1, state2, _ = sess.run([cost,
                                    lstm1.final_state,
                                    lstm2.final_state,
                                    train_op],
                                    feed_dict=feed_dict
                                    )
    costs += _cost; iters += num_steps

 

予測する

モデルを訓練した後、次の出力を予測するとき、ステップ数 (シークエンス長) はもはや考慮しません、i.e. batch_size, num_steps は 1 に設定されます。それで単語のシークエンスから単語のシークエンスを予測する代わりに、一つずつ次の単語を出力できます。

input_data_test = tf.placeholder(tf.int32, [1, 1])
targets_test = tf.placeholder(tf.int32, [1, 1])
...
network_test, lstm1_test, lstm2_test = inference(input_data_test,
                      is_training=False, num_steps=1, reuse=True)
...
cost_test = loss_fn(network_test.outputs, targets_test, 1, 1)
...
print("Evaluation")
# Testing
# go through the test set step by step, it will take a while.
start_time = time.time()
costs = 0.0; iters = 0
# reset all states at the beginning
state1 = tl.layers.initialize_rnn_state(lstm1_test.initial_state)
state2 = tl.layers.initialize_rnn_state(lstm2_test.initial_state)
for step, (x, y) in enumerate(tl.iterate.ptb_iterator(test_data,
                                        batch_size=1, num_steps=1)):
    feed_dict = {input_data_test: x, targets_test: y,
                lstm1_test.initial_state: state1,
                lstm2_test.initial_state: state2,
                }
    _cost, state1, state2 = sess.run([cost_test,
                                    lstm1_test.final_state,
                                    lstm2_test.final_state],
                                    feed_dict=feed_dict
                                    )
    costs += _cost; iters += 1
test_perplexity = np.exp(costs / iters)
print("Test Perplexity: %.3f took %.2fs" % (test_perplexity, time.time() - start_time))

 

What Next?

今では、貴方は同期した入力と出力を理解しました。"Many to one (シークエンス入力と一つの出力)" について考えましょう、その結果 LSTM は “I am from London, I speak ..” から次の単語 "English" を予測することができます。

tutorial_generate_text.py のコードを読んで理解してください。それは事前訓練された埋め込み行列をどのように restore するか、そして与えられたコンテキストからどのようにテキスト生成を学習するかを示します。

Karpathy のブログ : “(3) センテンス入力 (e.g. センチメント解析、そこでは与えられたセンテンスが正あるいは負のセンチメントを表わすとして分類されます)。"

 

以上






TensorFlow : TensorLayer : チュートリアル (4) Word2Vec

TensorFlow : TensorLayer : チュートリアル (4) Word2Vec (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 12/05/2018

* 本ページは、TensorLayer の以下のドキュメントの一部を翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

チュートリアル (4)

Word2Vec サンプルを実行する

チュートリアルのこのパートでは、単語群のための行列を訓練します、そこでは各単語は行列の一意の行ベクトルにより表すことができます。最後には、類似の単語は類似のベクトルを持つでしょう。それから単語群を 2-次元平面にプロット出力するとき、類似の単語は互いに近くに群がることになります。

python tutorial_word2vec_basic.py

総てが正しくセットアップされれば、最後に出力を得るでしょう。

 

単語埋め込みを理解する

単語埋め込み

何故ベクトル表現を使用することを望むのか、そしてベクトルをどのように計算するかを理解するために Colah のブログ Word Representations を読むことを強く勧めます。word2vec についてのより詳細は Word2vec Parameter Learning Explained で見つけられます。

基本的には、埋め込み行列の訓練は教師なし学習です。総ての単語が一意の ID で表わされるとき、それは埋め込み行列の行インデックスで、単語はベクトルに変換できて、それは意味をより良く表わすことができます。例えば、一定の male-female 差分ベクトルがあるようです: woman − man = queen – king, これはベクトルの 1 次元が性別を表わすことを意味します。

モデルは次のように作成できます。

# train_inputs is a row vector, a input is an integer id of single word.
# train_labels is a column vector, a label is an integer id of single word.
# valid_dataset is a column vector, a valid set is an integer id of single word.
train_inputs = tf.placeholder(tf.int32, shape=[batch_size])
train_labels = tf.placeholder(tf.int32, shape=[batch_size, 1])
valid_dataset = tf.constant(valid_examples, dtype=tf.int32)

# Look up embeddings for inputs.
emb_net = tl.layers.Word2vecEmbeddingInputlayer(
        inputs = train_inputs,
        train_labels = train_labels,
        vocabulary_size = vocabulary_size,
        embedding_size = embedding_size,
        num_sampled = num_sampled,
        nce_loss_args = {},
        E_init = tf.random_uniform_initializer(minval=-1.0, maxval=1.0),
        E_init_args = {},
        nce_W_init = tf.truncated_normal_initializer(
                          stddev=float(1.0/np.sqrt(embedding_size))),
        nce_W_init_args = {},
        nce_b_init = tf.constant_initializer(value=0.0),
        nce_b_init_args = {},
        name ='word2vec_layer',
    )

 

データセット反復と損失

Word2vec は訓練のためにネガティブ・サンプリングと Skip-Gram モデルを使用します。Noise-Contrastive Estimation (NCE) 損失は損失の計算を減じるのを助けることができます。Skip-Gram はコンテキストとターゲットを反対にして、そのターゲット単語から各コンテキスト単語を予測することを試みます。次のように訓練データを生成するために tl.nlp.generate_skip_gram_batch を使用します、tutorial_generate_text.py を見てください。

# NCE cost expression is provided by Word2vecEmbeddingInputlayer
cost = emb_net.nce_cost
train_params = emb_net.all_params

train_op = tf.train.AdagradOptimizer(learning_rate, initial_accumulator_value=0.1,
          use_locking=False).minimize(cost, var_list=train_params)

data_index = 0
while (step < num_steps):
  batch_inputs, batch_labels, data_index = tl.nlp.generate_skip_gram_batch(
                data=data, batch_size=batch_size, num_skips=num_skips,
                skip_window=skip_window, data_index=data_index)
  feed_dict = {train_inputs : batch_inputs, train_labels : batch_labels}
  _, loss_val = sess.run([train_op, cost], feed_dict=feed_dict)

 

既存の埋め込み行列を restore する

埋め込み行列を訓練する最後に、行列と対応する辞書をセーブします。それから次回、行列と辞書を次のように restore できます。(tutorial_generate_text.py の main_restore_embedding_layer 参照)

vocabulary_size = 50000
embedding_size = 128
model_file_name = "model_word2vec_50k_128"
batch_size = None

print("Load existing embedding matrix and dictionaries")
all_var = tl.files.load_npy_to_any(name=model_file_name+'.npy')
data = all_var['data']; count = all_var['count']
dictionary = all_var['dictionary']
reverse_dictionary = all_var['reverse_dictionary']

tl.nlp.save_vocab(count, name='vocab_'+model_file_name+'.txt')

del all_var, data, count

load_params = tl.files.load_npz(name=model_file_name+'.npz')

x = tf.placeholder(tf.int32, shape=[batch_size])
y_ = tf.placeholder(tf.int32, shape=[batch_size, 1])

emb_net = tl.layers.EmbeddingInputlayer(
                inputs = x,
                vocabulary_size = vocabulary_size,
                embedding_size = embedding_size,
                name ='embedding_layer')

tl.layers.initialize_global_variables(sess)

tl.files.assign_params(sess, [load_params[0]], emb_net)
 

以上






TensorFlow : TensorLayer : チュートリアル (3) 深層強化学習

TensorFlow : TensorLayer : チュートリアル (3) 深層強化学習 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 12/04/2018

* 本ページは、TensorLayer の以下のドキュメントの一部を翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

チュートリアル (3)

Pong Game サンプルを実行する

チュートリアルの 2nd パートでは、深層強化学習サンプルを実行します、これは Deep Reinforcement Learning: Pong from Pixels で Karpathy により紹介されています。

python tutorial_atari_pong.py

チュートリアル・コードを実行する前に、OpenAI gym 環境をインストールする必要があります、これは強化学習のためのポピュラーなベンチマークです。総てが正しくセットアップされれば、次のような出力を得るでしょう :

[2016-07-12 09:31:59,760] Making new env: Pong-v0
  [TL] InputLayer input_layer (?, 6400)
  [TL] DenseLayer relu1: 200, relu
  [TL] DenseLayer output_layer: 3, identity
  param 0: (6400, 200) (mean: -0.000009  median: -0.000018 std: 0.017393)
  param 1: (200,)      (mean: 0.000000   median: 0.000000  std: 0.000000)
  param 2: (200, 3)    (mean: 0.002239   median: 0.003122  std: 0.096611)
  param 3: (3,)        (mean: 0.000000   median: 0.000000  std: 0.000000)
  num of params: 1280803
  layer 0: Tensor("Relu:0", shape=(?, 200), dtype=float32)
  layer 1: Tensor("add_1:0", shape=(?, 3), dtype=float32)
episode 0: game 0 took 0.17381s, reward: -1.000000
episode 0: game 1 took 0.12629s, reward: 1.000000  !!!!!!!!
episode 0: game 2 took 0.17082s, reward: -1.000000
episode 0: game 3 took 0.08944s, reward: -1.000000
episode 0: game 4 took 0.09446s, reward: -1.000000
episode 0: game 5 took 0.09440s, reward: -1.000000
episode 0: game 6 took 0.32798s, reward: -1.000000
episode 0: game 7 took 0.74437s, reward: -1.000000
episode 0: game 8 took 0.43013s, reward: -1.000000
episode 0: game 9 took 0.42496s, reward: -1.000000
episode 0: game 10 took 0.37128s, reward: -1.000000
episode 0: game 11 took 0.08979s, reward: -1.000000
episode 0: game 12 took 0.09138s, reward: -1.000000
episode 0: game 13 took 0.09142s, reward: -1.000000
episode 0: game 14 took 0.09639s, reward: -1.000000
episode 0: game 15 took 0.09852s, reward: -1.000000
episode 0: game 16 took 0.09984s, reward: -1.000000
episode 0: game 17 took 0.09575s, reward: -1.000000
episode 0: game 18 took 0.09416s, reward: -1.000000
episode 0: game 19 took 0.08674s, reward: -1.000000
episode 0: game 20 took 0.09628s, reward: -1.000000
resetting env. episode reward total was -20.000000. running mean: -20.000000
episode 1: game 0 took 0.09910s, reward: -1.000000
episode 1: game 1 took 0.17056s, reward: -1.000000
episode 1: game 2 took 0.09306s, reward: -1.000000
episode 1: game 3 took 0.09556s, reward: -1.000000
episode 1: game 4 took 0.12520s, reward: 1.000000  !!!!!!!!
episode 1: game 5 took 0.17348s, reward: -1.000000
episode 1: game 6 took 0.09415s, reward: -1.000000

このサンプルは、丁度人間の挙動のように、ニューラルネットワークに画面入力から Pong ゲームをどのようにプレーするかを学習することを可能にします。ニューラルネットワークは fake AI プレーヤーとプレーしてそれを打ち負かすことを学習します。15,000 エピソードの訓練後、ニューラルネットワークはゲームの 20% 勝利できます。ニューラルネットワークは 20,000 エピソードでゲームの 35% 勝利し、それが訓練するためのより多くの勝利データを持つにつれ、ニューラルネットワークがより速く学習することを見ることができます。30,000 エピソードの間それを実行すれば、それは決して敗北しません。

render = False
resume = False

ゲーム環境を表示したい場合、render を True に設定します。コードを再度実行するとき、resume を True に設定できます、コードは存在するモデルをロードしてその上で基本モデルをその上で訓練します。


 

強化学習を理解する

Pong ゲーム

強化学習を理解するため、元の画面入力から Pong ゲームをどのようにプレーするかをコンピュータに学習させます。始める前に、Deep Reinforcement Learning: Pong from Pixels と呼ばれる有名なブログを調べることを強く勧めます、これは python-numpy と OpenAI gym 環境を使用した深層強化学習のミニマリズム的な実装です。

python tutorial_atari_pong.py

 

ポリシーネットワーク

深層強化学習では、ポリシーネットワークは深層ニューラルネットワークと同じで、私達が何をすべきか (move UP or DOWN) を知らせるアクションを出力するのはプレーヤー (or 「エージェント」) です; Karpathy のコードでは、2 つのアクション, UP と DOWN, だけを定義して単一の sigmoid 出力を使用していました; チュートリアルをより一般的にするために、3 softmax 出力を使用して 3 つのアクションを定義しました、これは UP, DOWN と STOP (do nothing) です。

# observation for training
states_batch_pl = tf.placeholder(tf.float32, shape=[None, D])

network = tl.layers.InputLayer(states_batch_pl, name='input_layer')
network = tl.layers.DenseLayer(network, n_units=H,
                                act = tf.nn.relu, name='relu1')
network = tl.layers.DenseLayer(network, n_units=3,
                        act = tf.identity, name='output_layer')
probs = network.outputs
sampling_prob = tf.nn.softmax(probs)

それからエージェントが Pong をプレーしているとき、それは異なるアクションの確率を計算し、そして一様分布からサンプル (アクション) をドローします。アクションは 1, 2 と 3 で表わされますが、softmax 出力は 0 から始まるべきなので、ラベル値をマイナス 1 して計算します。

prob = sess.run(
    sampling_prob,
    feed_dict={states_batch_pl: x}
)
# action. 1: STOP  2: UP  3: DOWN
action = np.random.choice([1,2,3], p=prob.flatten())
...
ys.append(action - 1)

 

ポリシー勾配

ポリシー勾配法は状態をアクションにマップするポリシー関数を直接学習する end-to-end アルゴリズムです。近似ポリシーは期待報酬を最大化することにより直接学習可能でしょう。ポリシー関数のパラメータ (e..g. pong サンプルで使用されるポリシーネットワークのパラメータ) は期待報酬の勾配のガイダンスのもとで訓練されて学習可能です。換言すれば、そのパラメータを更新することを通してポリシー関数を徐々に調整できます、その結果それは与えられた状態からより高い報酬に向けてアクションを生成します。

ポリシー勾配の代替方法は深層Q学習 (DQN) です。それは、状態とアクションをある値にマップする (Q 関数と呼ばれる) 値関数 (= value function) を学習することを試みる Q-学習に基づきます。DQN は Q 関数を関数近似器として表わすために深層ニューラルネットワークを用います。訓練は temporal-difference 誤差 (訳注: = TD 誤差) を最小化することにより成されます。「経験再生 (= experience replay)」と呼ばれる神経生物学的にインスパイアされたメカニズムが、非線形関数近似器の使用に起因するその安定性を改良することを手助けするために DQN と一緒に典型的には使用されます。

強化学習についてより良い理解を得るために次のペーパーをチェックすることができます。

  • Reinforcement Learning: An Introduction. Richard S. Sutton and Andrew G. Barto
  • Deep Reinforcement Learning. David Silver, Google DeepMind
  • UCL Course on RL

近年で深層強化学習の最も成功したアプリケーションは Atari ゲームと (最初にワールドクラスのプロ囲碁棋士を打ち負かした) AlphaGO をプレーするための経験再生を持つ DQN を含みます。AlphaGO は、Pong ゲームの例に類似したそのポリシーネットワークを訓練するためにポリシー勾配法を使用しました。

 

データセット反復

強化学習では、最後の決定をエピソードとして考えます。Pong ゲームでは、(一つの) エピソードは数十ゲームです、何故ならばゲームはどちらか一方のプレーヤーのための 21 のスコアが満点だからです。それでバッチサイズは幾つのエピソードをモデルを更新するために考えるかです。このチュートリアルでは、10 エピソードのバッチ上で RMSProp を使用して 200 隠れ層ユニットを持つ 2-層ポリシーネットワークを訓練します。

 

損失と更新式

訓練で最小化すべき損失式を作成します :

actions_batch_pl = tf.placeholder(tf.int32, shape=[None])
discount_rewards_batch_pl = tf.placeholder(tf.float32, shape=[None])
loss = tl.rein.cross_entropy_reward_loss(probs, actions_batch_pl,
                                              discount_rewards_batch_pl)
...
...
sess.run(
    train_op,
    feed_dict={
        states_batch_pl: epx,
        actions_batch_pl: epy,
        discount_rewards_batch_pl: disR
    }
)

バッチの損失はポリシーネットワークの総ての出力、行なった総てのアクションそしてバッチの対応する割引報酬に関連します。最初に割引報酬と出力と真のアクション間の交差エントロピーを乗算して各アクションの損失を計算します。

 

What Next?

上のチュートリアルは貴方自身のエージェントを end-to-end でどのように構築できるかを示します。それは合理的な品質を持つ一方で、デフォルトのパラメータは最善のエージェントモデルを与えないでしょう。改良できる 2, 3 のことがここにあります。

まず最初に、型通りの MLP モデルの代わりに、Playing Atari with Deep Reinforcement Learning が記述するように画面情報をよりよく捕捉するために CNN を使用することができます。

また、モデルのデフォルト・パラメータは調整されていません。学習率、減衰 (率) を変更したりモデルの重みを異なる方法で初期化してみることができます。

最後に、異なるタスク (ゲーム) 上でモデルを試して Example の他の強化学習アルゴリズムを試すことができます。

 

以上






TensorFlow : TensorLayer : チュートリアル (2) 画像分類 / Autoencoder

TensorFlow : TensorLayer : チュートリアル (2) 画像分類 / Autoencoder (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 12/02/2018

* 本ページは、TensorLayer の以下のドキュメントの一部を翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

チュートリアル (2)

MNIST example を実行する

チュートリアルの最初のパートでは、TensorLayer のソース配布に含まれる MNIST サンプルを単に実行します。MNIST データセットは様々な画像処理システムを訓練するために一般に使用される 60000 手書き数字を含みます。

フォルダに入り tutorial_mnist.py サンプル・スクリプトを実行します :

python tutorial_mnist.py

総てが正しくセットアップされている場合、次のような出力を得るでしょう :

tensorlayer: GPU MEM Fraction 0.300000
Downloading train-images-idx3-ubyte.gz
Downloading train-labels-idx1-ubyte.gz
Downloading t10k-images-idx3-ubyte.gz
Downloading t10k-labels-idx1-ubyte.gz

X_train.shape (50000, 784)
y_train.shape (50000,)
X_val.shape (10000, 784)
y_val.shape (10000,)
X_test.shape (10000, 784)
y_test.shape (10000,)
X float32   y int64

[TL] InputLayer   input_layer (?, 784)
[TL] DropoutLayer drop1: keep: 0.800000
[TL] DenseLayer   relu1: 800, relu
[TL] DropoutLayer drop2: keep: 0.500000
[TL] DenseLayer   relu2: 800, relu
[TL] DropoutLayer drop3: keep: 0.500000
[TL] DenseLayer   output_layer: 10, identity

param 0: (784, 800) (mean: -0.000053, median: -0.000043 std: 0.035558)
param 1: (800,)     (mean:  0.000000, median:  0.000000 std: 0.000000)
param 2: (800, 800) (mean:  0.000008, median:  0.000041 std: 0.035371)
param 3: (800,)     (mean:  0.000000, median:  0.000000 std: 0.000000)
param 4: (800, 10)  (mean:  0.000469, median:  0.000432 std: 0.049895)
param 5: (10,)      (mean:  0.000000, median:  0.000000 std: 0.000000)
num of params: 1276810

layer 0: Tensor("dropout/mul_1:0", shape=(?, 784), dtype=float32)
layer 1: Tensor("Relu:0", shape=(?, 800), dtype=float32)
layer 2: Tensor("dropout_1/mul_1:0", shape=(?, 800), dtype=float32)
layer 3: Tensor("Relu_1:0", shape=(?, 800), dtype=float32)
layer 4: Tensor("dropout_2/mul_1:0", shape=(?, 800), dtype=float32)
layer 5: Tensor("add_2:0", shape=(?, 10), dtype=float32)

learning_rate: 0.000100
batch_size: 128

Epoch 1 of 500 took 0.342539s
  train loss: 0.330111
  val loss: 0.298098
  val acc: 0.910700
Epoch 10 of 500 took 0.356471s
  train loss: 0.085225
  val loss: 0.097082
  val acc: 0.971700
Epoch 20 of 500 took 0.352137s
  train loss: 0.040741
  val loss: 0.070149
  val acc: 0.978600
Epoch 30 of 500 took 0.350814s
  train loss: 0.022995
  val loss: 0.060471
  val acc: 0.982800
Epoch 40 of 500 took 0.350996s
  train loss: 0.013713
  val loss: 0.055777
  val acc: 0.983700
...

このサンプルスクリプトは、多層パーセプトロン、ドロップアウト、Dropconnect, Stacked Denoising Autoencoder そして畳込みニューラルネットワークを含む、異なるモデルを試すことを可能にします。if __name__ == ‘__main__’: から異なるモデルを選択します。

main_test_layers(model='relu')
main_test_denoise_AE(model='relu')
main_test_stacked_denoise_AE(model='relu')
main_test_cnn_layer()

 

MNIST サンプルを理解する

さてそれを起こすために何が必要かを調査しましょう!追随するために、ソースコードを開いてください。

 

Preface

貴方が気づく最初のことは TensorLayer の他にも、numpy と tensorflow もインポートすることです :

import tensorflow as tf
import tensorlayer as tl
from tensorlayer.layers import set_keep
import numpy as np
import time

既知のように、TensorLayer は TensorFlow の上に構築されています、それは何某かのタスクを手伝う補足であり、置き換えではありません。TensorLayer を幾つかの vanilla TensorFlow コードと常に混在させるでしょう。set_keep は Denoising Autoencoder を使用するとき確率を保持する placeholder にアクセスするために使用されます。

 

データをロードする

コードの最初のピースは関数 load_mnist_dataset() を定義します。その目的は MNIST データセットを (もしそれがまだダウンロードされていないのであれば) ダウンドードしてそれを通常の numpy 配列の形式で返すことです。関連するような TensorLayer は全くありませんので、このチュートリアルのためには、それを次のように認識できます :

X_train, y_train, X_val, y_val, X_test, y_test = \
                  tl.files.load_mnist_dataset(shape=(-1,784))

X_train.shape は (50000, 784) です、これは次のように解釈されます: 50,000 画像と各画像は 784 ピクセルを持ちます。y_train.shape は単純に (50000,) です、これは X_train の同じ長さのベクトルで各画像のために整数クラスラベルを与えます – つまり、(数字を描いた人間の注釈者に従う) 画像で示される 0 と 9 の間の数字です 。

畳み込みニューラルネットワーク・サンプルのためには、MNIST は次のように 4D バージョンとしてロードされます :

X_train, y_train, X_val, y_val, X_test, y_test = \
            tl.files.load_mnist_dataset(shape=(-1, 28, 28, 1))

X_train.shape は (50000, 28, 28, 1) で、これはそれぞれ 1 チャネル、28 行と 28 列を持つ 50,000 画像を表します。チャネル 1 はそれがグレースケール画像であるためで、総てのピクセルは 1 つの値だけを持ちます。

 

モデルを構築する

これは TensorLayer が介入するところです。それは層を作成してスタックあるいはマージすることにより任意に構造化されたニューラルネットワークを定義することを可能にします。

上で言及したように、tutorial_mnist.py は 4 つのタイプのモデルをサポートし、そして同じインターフェイスの容易に交換可能な関数を通してそれを実装しています。最初に総てのステップを詳細に説明する固定されたアーキテクチャの多層パーセプトロン (MLP) を作成する関数を定義します。それから Denoising Autoencoder (DAE) を実装し、その後で総ての Denoising Autoencoder をスタックしてそれらを再調整します。加えて、tutorial_mnist_simple.py で MNIST データセットのための単純なサンプル、tutorial_cifar10_tfrecord.py で CIFAR-10 データセットのための CNN サンプル。

 

多層パーセプトロン (MLP)

最初のスクリプト main_test_layers() はそれぞれ 800 ユニットの 2 つの隠れ層を作成し、10 ユニットの softmax 出力層が続きます。それは入力データに 20% ドロップアウトそして隠れ層に 50% ドロップアウトを適用します。

データをネットワークに供給するために、TensorFlow placeholder が次のように定義される必要があります。ここで None はコンパイルの後ネットワークが任意のバッチサイズの入力データを受け取ることを意味します。x は X_train データを保持するために使用されて y_ は y_train データを保持するために使用されます。前もってバッチサイズを知りこの柔軟性を必要としない場合には、ここでバッチサイズを与えるべきです – 特に畳み込み層のためには、これは TensorFlow にある最適化を適用することを可能にします。

x = tf.placeholder(tf.float32, shape=[None, 784], name='x')
y_ = tf.placeholder(tf.int64, shape=[None, ], name='y_')

TensorFlow の各ニューラルネットワークの基礎はネットワークに続いて供給される入力データを表わす InputLayer インスタンスです。InputLayer はどのような特定のデータにもまだ結び付けられていないことに注意してください。

network = tl.layers.InputLayer(x, name='input')

最初の隠れ層を追加する前に、入力データに 20% ドロップアウトを適用します。これは DropoutLayer インスタンスを通して実現されます :

network = tl.layers.DropoutLayer(network, keep=0.8, name='drop1')

最初のコンストラクタ引数は incoming 層であることに注意してください、2 番目の引数は活性値のための保持確率です。さて続いて 800 ユニットの最初の完全結合隠れ層で進めます。DenseLayer をスタックするとき注意してください。

network = tl.layers.DenseLayer(network, n_units=800, act = tf.nn.relu, name='relu1')

再度、最初のコンストラクタ引数は network の上にネットワークをスタックしていることを意味しています。n_units はこの完全結合層に対するユニット数を与えます。act は活性化関数を取り、それらの幾つかは tensorflow.nn と tensorlayer.activation で定義されます。ここでは rectifier を選択しましたので、ReLU を得ます。50 % のドロップアウト、もう一つの 800-ユニット dense 層と再度 50 % ドロップアウトを追加します :

network = tl.layers.DropoutLayer(network, keep=0.5, name='drop2')
network = tl.layers.DenseLayer(network, n_units=800, act = tf.nn.relu, name='relu2')
network = tl.layers.DropoutLayer(network, keep=0.5, name='drop3')

最後に、完全結合出力層を追加します、この n_units はクラス数に等しいです。softmax は計算をスピードアップするために内部的には tf.nn.sparse_softmax_cross_entropy_with_logits() で実装されていますので、 最後の層では identity を使用することに注意してください、より詳細は tl.cost.cross_entropy() で。

network = tl.layers.DenseLayer(network,
                              n_units=10,
                              act = tf.identity,
                              name='output')

上で言及したように、各層はその incoming 層(s) にリンクされていますので、TensorLayer のネットワークにアクセスするためには出力層が必要なだけです :

y = network.outputs
y_op = tf.argmax(tf.nn.softmax(y), 1)
cost = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(y, y_))

ここで、network.output は network からの (one hot フォーマットの) 10 identity 出力で、y_op は整数出力ですクラスインデックスを表します。一方で cost はターゲットと予測ラベルの間の交差エントロピーです。

 

Denoising Autoencoder (DAE)

オートエンコーダは教師なし学習モデルで、表現特徴を抽出することができ、それはデータの学習生成モデルと Greedy layer-wise な事前訓練のためにより広く使用されるようになりました。vanilla オートエンコーダについては、深層学習チュートリアル を見てください。

スクリプト main_test_denoise_AE() は 50% の corrosion 率を持つ Denoising Autoencoder を実装しています。オートエンコーダは次のように定義されます、ここではオートエンコーダは DenseLayer で表わされます :

network = tl.layers.InputLayer(x, name='input_layer')
network = tl.layers.DropoutLayer(network, keep=0.5, name='denoising1')
network = tl.layers.DenseLayer(network, n_units=200, act=tf.nn.sigmoid, name='sigmoid1')
recon_layer1 = tl.layers.ReconLayer(network,
                                    x_recon=x,
                                    n_units=784,
                                    act=tf.nn.sigmoid,
                                    name='recon_layer1')

DenseLayer を訓練するためには、単純に ReconLayer.pretrain() を実行します、denoising Autoencoder を使用する場合、corrosion 層 (DropoutLayer) の名前が次のように指定される必要があります。特徴画像をセーブするために、save を True に設定します。異なるアーキテクチャとアプリケーションにより多くの種類の pre-train メトリクスがあります。sigmoid 活性のためには、オートエンコーダは KL ダイバージェンスを使用して実装できます、一方で rectifier のためには、活性出力の L1 正則化が出力をスパースにすることができます。そのため ReconLayer のデフォルトの挙動は KLD だけを提供して sigmoid 活性化関数のために交差エントロピーそして rectifying 活性化関数のために活性出力の L1 と平均二乗誤差 (mean-squared-error) です。貴方自身の pre-train メトリクスを達成するために ReconLayer を修正することを勧めます。

recon_layer1.pretrain(sess,
                      x=x,
                      X_train=X_train,
                      X_val=X_val,
                      denoise_name='denoising1',
                      n_epoch=200,
                      batch_size=128,
                      print_freq=10,
                      save=True,
                      save_name='w1pre_')

加えて、スクリプト main_test_stacked_denoise_AE() は一つのネットワークにどのように複数のオートエンコーダをスタックして再調整するかを示します。

 

畳み込みニューラルネットワーク (CNN)

最後に、main_test_cnn_layer() は 2 つの CNN 層と max pooling ステージ、完全結合隠れ層そして完全結合出力層を作成します。より多くの CNN サンプルは tutorial_cifar10_tfrecord.py のような他のサンプルで見つかります。

network = tl.layers.Conv2d(network, 32, (5, 5), (1, 1),
        act=tf.nn.relu, padding='SAME', name='cnn1')
network = tl.layers.MaxPool2d(network, (2, 2), (2, 2),
        padding='SAME', name='pool1')
network = tl.layers.Conv2d(network, 64, (5, 5), (1, 1),
        act=tf.nn.relu, padding='SAME', name='cnn2')
network = tl.layers.MaxPool2d(network, (2, 2), (2, 2),
        padding='SAME', name='pool2')

network = tl.layers.FlattenLayer(network, name='flatten')
network = tl.layers.DropoutLayer(network, keep=0.5, name='drop1')
network = tl.layers.DenseLayer(network, 256, act=tf.nn.relu, name='relu1')
network = tl.layers.DropoutLayer(network, keep=0.5, name='drop2')
network = tl.layers.DenseLayer(network, 10, act=tf.identity, name='output')

 

モデルを訓練する

tutorial_mnist.py スクリプトの残りの部分はセットアップして交差エントロピーだけを使用して MNIST データセットに渡り訓練ループを実行することを処理します。

 

Dataset iteration

iteration 関数は、与えられた項目数のミニバッチでそれぞれ入力データとターゲットの 2 つの numpy 配列 に渡り同期的に反復するためのものです。より多くの iteration 関数は tensorlayer.iterate で見つかります。

tl.iterate.minibatches(inputs, targets, batchsize, shuffle=False)

 

損失と更新式

続けて、訓練で最小化されるべき損失式を作成します :

y = network.outputs
y_op = tf.argmax(tf.nn.softmax(y), 1)
cost = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(y, y_))

より多くの損失または正則化はここで適用できます。例えば、重み行列上の max-norm を適用するために、次の行を追加できます。

cost = cost + tl.cost.maxnorm_regularizer(1.0)(network.all_params[0]) +
              tl.cost.maxnorm_regularizer(1.0)(network.all_params[2])

解いている問題に依拠して、異なる損失関数が必要となるでしょう、より多くは tensorlayer.cost を見てください。変数を得るために、network.all_params を使用する以外に、特定の変数を文字列名で得るために tl.layers.get_variables_with_name を使用することもできます。

ここでモデルと損失関数を持ち、ネットワークを訓練するための更新式/演算を作成します。TensorLayer は多くの optimizer を提供しません、代わりに TensorFlow の optimizer を使用しました :

train_params = network.all_params
train_op = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.999,
    epsilon=1e-08, use_locking=False).minimize(cost, var_list=train_params)

ネットワークを訓練するために、feed_dict へデータと 保持確率を供給しました。

feed_dict = {x: X_train_a, y_: y_train_a}
feed_dict.update( network.all_drop )
sess.run(train_op, feed_dict=feed_dict)

その一方で、検証とテストについては、少し異なる方法を使用します。総ての Dropout, Dropconnect, Corrosion 層は無効にされる必要があります。総ての network.all_drop を 1 に設定するために tl.utils.dict_to_one を使用します。

dp_dict = tl.utils.dict_to_one( network.all_drop )
feed_dict = {x: X_test_a, y_: y_test_a}
feed_dict.update(dp_dict)
err, ac = sess.run([cost, acc], feed_dict=feed_dict)

評価のためには、分類精度のための式を作成します :

correct_prediction = tf.equal(tf.argmax(y, 1), y_)
acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

 

What Next?

私達はまた tutorial_cifar10_tfrecord.py でより多くの進んだ画像分類サンプルを持ちます。コードとノートを読み、より多くの訓練データをどのように生成するかそして local response normalization とは何かを理解してください。その後で、残差ネットワークを実装することを試してください (Hint: you may want to use the Layer.outputs)。

 

以上






TensorFlow : TensorLayer : チュートリアル (1) Welcome

TensorFlow : TensorLayer : チュートリアル (1) Welcome (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 12/01/2018

* 本ページは、TensorLayer の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

TensorLayer : README.md

TensorLayer は研究者と技術者のための新しい TensorFlow-ベースの深層学習そして強化学習ライブラリです。それは現実世界の AI アプリケーションを構築するための鍵となるカスタマイズ可能なニューラル層 / 関数の巨大なコレクションを提供します。TensorLayer は ACM Multimedia Society により 2017 ベスト・オープンソース・ソフトウェアとして表彰されています。

 

特徴

深層学習実践者として、様々な開発目的を扱えるライブラリを探し求めていました。このライブラリは多様なサンプル、チュートリアルそして事前訓練されたモデルを提供することにより採用することが容易です。また、それはユーザに TensorFlow を容易に再調整する (= fine-tune) ことを可能にします; その一方でプロダクション配備のために適合します。TensorLayer はこれら総ての目的を満たすことを目指します。それは 3 つのキー特徴を持ちます :

  • 単純性 : TensorLayer は TensorFlow の低位データフロー・インターフェイスを高位層 / モデルにリフトします。広いコミュニティにより貢献された豊富はサンプルコードを通して学習することは非常に容易です。
  • 柔軟性 : TensorLayer API は透過的です : それは TensorFlow をユーザからマスクしません ; 低位調整と深いカスタマイゼーションを手助けする大希望なフックを残します。
  • Zero-cost 抽象 : TensorLayer は TensorFlow の完全なパワーを達成します。

TensorLayer はライブラリ風景のユニークな位置に立ちます。Keras と TFLearn のような他のラッパー・ライブラリもまた高位抽象を提供します。けれども、それらはユーザから基礎をなすエンジンをしばしば隠します、それはそれらをカスタマイズして再調整することを困難にします。反対に、TensorLayer API は一般に柔軟で透過的です。ユーザはサンプルとチュートリアルで始めて、それから TensorFlow にシームレスにダイブすることが容易であることをしばしば見い出すでしょう。加えて、TensorLayer は Keras, TFSlim と TFLearn からのコンポーネントをインポートするためのネイティブ・サポートを通してロックインされたライブラリを作成しません。

TensorLayer は Imperial College London, UC Berkeley, Carnegie Mellon University, Stanford University, と University of Technology of Compiegne (UTC) のような大学、そして Google, Microsoft, Alibaba, Tencent, Xiaomi, と Bloomberg のような企業からのトップ研究者と技術者の中で素早く高まる利用を持ちます。

 

チュートリアル (1)

深層学習について、このチュートリアルは (おそらくニューラルネットワークの “Hello World” である) MNIST データセットを使用して貴方に手書き数字分類器の構築を案内します。強化学習については、元のスクリーン入力からコンピュータに Pong ゲームをプレーすることを学習させます。自然言語処理については、単語埋め込みから始めてそして言語モデリングと機械翻訳を記述します。

このチュートリアルは Google TensorFlow 深層学習チュートリアルの総てのモジュール化された実装を含みますので、TensorFlow 深層学習チュートリアルを同時に読むこともできます。

Note: For experts: InputLayer と DenseLayer のソースコードを読んでください、TensorLayer がどのように動作するか理解するでしょう。その後、Github のコードを直接読むことを進めます。

 

Before we start

チュートリアルは貴方がニューラルネットワークと TensorFlow にある程度精通していることを仮定しています。Deeplearning Tutorial からニューラルネットワークの基礎を学習することを試せます。

人工ニューラルネットワークへのよりスローペースなイントロダクションについては、Andrej Karpathy et al. による Convolutional Neural Networks for Visual Recognition、Michael Nielsen による Neural Networks と Deep Learning を勧めます。

TensorFlow について更に学習するためには、TensorFlow チュートリアルを見てください。それの総てを必要とはしませんが、TensorLayer を使用できるためにはどのように TensorFlow が動作するかについて基本的な理解は必要です。

 

TensorLayer is simple

次のコードは TensorLayer の単純な例を示します、tutorial_mnist_simple.py を見てください。私達は多くの単純な関数(like fit() , test() ) を提供しますけれども、詳細を理解して機械学習エキスパートになることを望むのであれば、データ反復ツールボックス (tl.iterate) と sess.run() のような TensorFlow のネイティブ API を使用してネットワークを訓練することを提案します。より詳細は tutorial_mnist.py, tutorial_mlp_dropout1.py と tutorial_mlp_dropout2.py を見てください。

import tensorflow as tf
import tensorlayer as tl

sess = tf.InteractiveSession()

# prepare data
X_train, y_train, X_val, y_val, X_test, y_test = \
                                tl.files.load_mnist_dataset(shape=(-1,784))

# define placeholder
x = tf.placeholder(tf.float32, shape=[None, 784], name='x')
y_ = tf.placeholder(tf.int64, shape=[None, ], name='y_')

# define the network
network = tl.layers.InputLayer(x, name='input_layer')
network = tl.layers.DropoutLayer(network, keep=0.8, name='drop1')
network = tl.layers.DenseLayer(network, n_units=800,
                                act = tf.nn.relu, name='relu1')
network = tl.layers.DropoutLayer(network, keep=0.5, name='drop2')
network = tl.layers.DenseLayer(network, n_units=800,
                                act = tf.nn.relu, name='relu2')
network = tl.layers.DropoutLayer(network, keep=0.5, name='drop3')
# the softmax is implemented internally in tl.cost.cross_entropy(y, y_, 'cost') to
# speed up computation, so we use identity here.
# see tf.nn.sparse_softmax_cross_entropy_with_logits()
network = tl.layers.DenseLayer(network, n_units=10,
                                act = tf.identity,
                                name='output_layer')
# define cost function and metric.
y = network.outputs
cost = tl.cost.cross_entropy(y, y_, 'cost')
correct_prediction = tf.equal(tf.argmax(y, 1), y_)
acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
y_op = tf.argmax(tf.nn.softmax(y), 1)

# define the optimizer
train_params = network.all_params
train_op = tf.train.AdamOptimizer(learning_rate=0.0001, beta1=0.9, beta2=0.999,
                            epsilon=1e-08, use_locking=False).minimize(cost, var_list=train_params)

# initialize all variables in the session
tl.layers.initialize_global_variables(sess)

# print network information
network.print_params()
network.print_layers()

# train the network
tl.utils.fit(sess, network, train_op, cost, X_train, y_train, x, y_,
            acc=acc, batch_size=500, n_epoch=500, print_freq=5,
            X_val=X_val, y_val=y_val, eval_train=False)

# evaluation
tl.utils.test(sess, network, acc, X_test, y_test, x, y_, batch_size=None, cost=cost)

# save the network to .npz file
tl.files.save_npz(network.all_params , name='model.npz')
sess.close()
 

以上






AI導入支援 #2 ウェビナー

スモールスタートを可能としたAI導入支援   Vol.2
[無料 WEB セミナー] [詳細]
「画像認識 AI PoC スターターパック」の紹介
既に AI 技術を実ビジネスで活用し、成果を上げている日本企業も多く存在しており、競争優位なビジネスを展開しております。
しかしながら AI を導入したくとも PoC (概念実証) だけでも高額な費用がかかり取組めていない企業も少なくないようです。A I導入時には欠かせない PoC を手軽にしかも短期間で認知度を確認可能とするサービの紹介と共に、AI 技術の特性と具体的な導入プロセスに加え運用時のポイントについても解説いたします。
日時:2021年10月13日(水)
会場:WEBセミナー
共催:クラスキャット、日本FLOW(株)
後援:働き方改革推進コンソーシアム
参加費: 無料 (事前登録制)
人工知能開発支援
◆ クラスキャットは 人工知能研究開発支援 サービスを提供しています :
  • テクニカルコンサルティングサービス
  • 実証実験 (プロトタイプ構築)
  • アプリケーションへの実装
  • 人工知能研修サービス
◆ お問合せ先 ◆
(株)クラスキャット
セールス・インフォメーション
E-Mail:sales-info@classcat.com