終末 A.I.

Deep Learning を中心に、機械学習するエンジニアのブログ

RNN より高速な Feedforward Sequential Memory Networks (FSMN) を TensorFlow で実装してみた

LSTM や GRU など RNN の一般的なアーキテクチャの弱点としては、DNN や CNN に比べた場合に処理の遅さがあげられます。それは、アーキテクチャからは自明で、LSTM や GRU のような系列の記憶としての隠れ変数を使用する層の場合、あるステップの計算を行う時には事前のステップまでの計算を完了している必要があるため計算の並列化が難しい点、ステップ数が深くなればなるほど逆伝搬が深くなってしまいその分の計算コストが高くなる点があるため、GPU を使った場合も処理速度に限界があります。

Zhang 氏らが提案している Feedforward Sequential Memory Networks: A New Structure to Learn Long-term Dependency(FSMN) は、既存の RNN の構造とは異なり、メモリを使用することによりシーケンシャルな構造を考慮した学習を行う事ができます。

論文中では、スカラーFSMN、ベクトルFSMN、双方向FSMNなどのアーキテクチャを提案していますが、この記事では代表してスカラーFSMNを紹介したいと思います。FSMNの構造はシンプルで、FSMN 層に入力された隠れ変数 {h^{l}_{t}}をメモリーに記憶しておき、そのメモリーに記憶されている値も考慮して次の層への出力を生成するという形をしています。

スカラーFSMNの更新式は、下記の2つで表すことができます。

[tex:{ \tilde{h}^{l}{t} = \sum^{N}{i} a^{l}{i} h^{l}{t-i} }]

[tex:{ h^{l+1}{t} = f(W^{l} h^{l}{t} + \tilde{W}^{l}{t} \tilde{h}^{l}{t} + b^{l}) }]

上記を見ての通りで、メモリブロックを考慮した値として [tex:{\tilde{h}^{l}{t}}] を生成しますが、スカラーFSMNの場合は[tex:{a^{l}{i}}]という係数を重みとしたメモリの和として定義します。あとはもとの入力とこの値を普通のニューラルネットの重み計算を行うことにより、FSMN層の出力とします。

順伝搬計算の場合、通常の RNN とは違い、事前のステップの入力が必要になりますがこの層内での計算結果を必要としないため、層単位で並列に計算することができます。 また逆伝搬の計算ですが、ステップ数が深くなっても学習に必要な逆伝搬が深くならず、さらに並列に計算することが可能となるため、通常の RNN と比べ計算を高速に処理することができるようになります。 一応論文中では、識別器としての性能も大差ないよと言っています。

というわけで、簡単に紹介したところで、TensorFlow で実装し既存のLSTMと比較してみましょう。比較実験のお題としては、TensorFlow の PTB サンプルを使用します。実験環境としては、g2.2xlarge を使用します。FSMN用のコードは、github にもアップしています。

実験条件としては、TensorFlow の PTB サンプルに付属している reader.py を使用して、バッチサイズを 20 、ステップ数を 50 として、エンベッド層、一層のFSMN層 もしくは LSTM層、出力層の三層構造でそれぞれの隠れユニットは 400 、エポック数は 10 とします。

TIME Validation PPL
LSTM 22m11.378s 122.462
FSMN 23m58.838s 148.335

結果を見る限りだと、PPL はともかく残念ながら速度が全然改善してませんね。論文によると4分の3くらいの速度になるようなので、僕の実装の問題なのでしょうが、TensorFlow との相性もあるんでしょうか。コード公開してもらえると再現実験楽でいいんですけどね。

2016/12/11 追記

コードの冗長性を除去して実験したところ、下記のように倍くらいの速度で処理をすることができました。PPLは残念ながら変わらずですが(変わったら変わったで何のこっちゃですが)、処理を見直すのってやはり大事ですね。修正済みのコードは、github にもアップしていますので良ければご活用ください。

TIME Validation PPL
FSMN 11m51.884s 148.740

Prisma で使われているという Neural Style を試してみた

7月くらいに話題に上がっていました Prisma ですが、皆さん覚えていらっしゃるでしょうか。Prisma では、A Neural Algorithm of Artistic Style というアルゴリズムをベースに、面白画像を生成していると言われていますが、10月の頭にその高速化手法であるPerceptual Losses for Real-Time Style Transfer and Super-Resolution が著者自身の手によりソースコードとともに公開されました。ちなみに論文自体は3月ごろには arxive に公開されており、yusuketomoto 氏による Chainer 実装 がほぼ同時期に公開されています。この手法では、低解像度の画像であればGPUを使用してほぼリアルタイムで Prisma のような画像を生成することが可能になるということで、ベース手法より実用性があがっています。

この記事ではその2つのアルゴリズムの中身がどのようになっているのかや実行速度などを比較してみたいと思います。

まず、ベース手法である A Neural Algorithm of Artistic Style ですが、こちらはコンテンツ画像とスタイル画像の2つをもとに、ImageNet などで学習させた Pre-Trained なモデル(論文中では VGG-19 のモデル)を使用して、スタイル画像から抜き出したスタイルを適用したコンテンツ画像を生成するというものです。

ランダムに生成した画像とコンテンツ画像およびスタイル画像をDCNNに入力し、生成画像とコンテンツ画像の特定層の出力の差と、生成画像とスタイル画像の特定の層までの出力の差を誤差として、SGD を生成画像に適用することにより生成画像をだんだんと期待する出力画像に近づけていくという処理を行っています。そのため一つの画像を生成するためには、500イテレーションや1000 イテレーションなどの大量の DCNN の学習処理を行う必要があり、どうしても画像の生成に時間がかかってしまいます。

一方で、改良版である Perceptual Losses for Real-Time Style Transfer and Super-Resolution は、学習により画像そのものを生成するのではなく、コンテンツ画像を入力とし、その画像に特定のスタイルを適用した画像を出力するような DCNN を生成することを学習の目的としています。上記の Neural Style で使用したような Pre-Trained のモデルを誤差計算用に用い、そこで計算された誤差をもとに画像を生成するためのニューラルネットワークを学習させていきます。

そのため画像の生成については、一回きりの順伝搬計算ですむので非常に高速にスタイルを適用した画像を生成することができます。スタイル毎にモデルを生成しなければならない点、モデルの学習に大量の時間とデータが必要になるというデメリットはありますが、実際にサーバ等で動作させることを考える場合はこちらの手法を取るほうが現実的でしょう。

以下はそれぞれの手法を AWS の g2.x2.large インスタンスで試してみた結果となります。適用スタイルとしては、Perceptual Losses for Real-Time Style Transfer and Super-Resolution で用意されているスタイルのうちモザイクのスタイルを適用しています。

実験には、Perceptual Losses for Real-Time Style Transfer and Super-Resolution の著者の一人である、jcjohnson 氏が公開している fast-neural-style という Torch のコードを使用しています。

ベース手法の方は、下記のように500イテレーション回して、GPUで3分17秒ほどかかります。

th slow_neural_style.lua -style_image images/styles/mosaic.jpg -content_image neko.jpg -output_image slow-ret.jpg -gpu 0 -backend cuda -use_cudnn 1 -optimizer adam -num_iterations 500 -save_every 100

一方で、fast-neural-style の方は、下記のようにモザイクスタイルのモデルを指定して、GPUで10秒ほどで完了します。実際はモデルのロードが完了しているような環境で実行するでしょうから、PCのスペックによってはデモにもあるようにほぼリアルタイムに変換を行うことも可能です。

th fast_neural_style.lua -model models/instance_norm/mosaic.t7 -input_image neko.jpg -output_image fast-ret.jpg -gpu 0 -backend cuda -use_cudnn 1 -cudnn_benchmark 1

変換結果は下記のようになりました。上から、ぱんくたそ さんから拝借してきたフリー素材の猫画像、ベース手法で変換した結果、高速化版で変換した結果の画像となります。高速化版はベース手法に比べてスタイルの適用だけでなくコンテンツ画像の利用もうまいこと行えていることがわかります。このあたりパラメーターチューニングの問題なのか、変換用の DCNN をかますことにより発生しているのかよく分かっていませんが、ちょっと動かすだけでこのクオリティの画像が生成されるのは驚きですね。

好きなスタイルを適用するためのモデルを生成するためのコードも公開されていますので、興味のある方はぜひ試してみてください!

元画像:

f:id:KSKSKSKS2:20161030002417j:plain:h200

ベース手法で変換した画像:

f:id:KSKSKSKS2:20161030002430j:plain:h200

高速化版手法で変換した画像:

f:id:KSKSKSKS2:20161030002438j:plain:h200

参考

TensorFlow の cifar10 サンプルを動かす

一般的な DNN、RNN と続いて、今回は CNN を TensorFlow の cifar10 サンプルを元に動かしてみたいと思います。

AWSでのGPU環境の整備や、TensorFlow の基本的な使い方については、手前味噌ですが下記の記事をご覧ください。

また、CNNって何?どういう仕組なの?という方は、以下の書籍が入門用によくまとまっていますのでご一読をおすすめします。

深層学習 (機械学習プロフェッショナルシリーズ)

深層学習 (機械学習プロフェッショナルシリーズ)

深層学習 Deep Learning (監修:人工知能学会)

深層学習 Deep Learning (監修:人工知能学会)

この記事で実際に学習および評価に使用したコードは、記事の一番下に記載してあります。Python は 3.4.3、TensorFlow は 0.9 を使用していますが、しばらくはバージョンが上がっても微調整でちゃんと動くのではないかと思います。

さて前置きはこれくらいにしまして、TensorFlow の cifar10 の識別用CNNを作成するサンプルですが、TensorFlow 独特の実装を行っているポイントが2つあります。 一つが読み込んだデータを元にミニバッチごとのデータを出力する部分。もう一つが TensrFlow の API を利用した CNN に必要となる Covolution 層、Pooling 層、正規化層の利用方法です。早速それぞれがどのように実装されているかを見てみましょう。

まずデータを読み込んでミニバッチ用のデータを生成する処理ですが、TensorFlow の HowTo ページの Reading dataソースコードに添付されている examples/how_tos/reading_data のサンプルコードに記載のあるように、処理用のデータを逐次読みだすための仕組みによって実現されています。

TensorFlow に付属しているサンプルコードでは、cifar10_input.py 内でバイナリ形式で保存された cifar10 のファイルを読み込んで、データをシャッフルした上でミニバッチで使用する数だけ出力するという処理を、tf.train.string_input_producer、tf.FixedLengthRecordReader、tf.train.batch を使用して実現しています。このコードでは、キューに登録してあるファイルを開いて、必要な時に必要な量だけそのファイルからメモリにロードするといった処理が行われることになります。

私が書いた方のコードでは、Python 用に公開されている Pickle 形式で保存された cifar10 のデータをひとまず全部メモリにロードしておき、ミニバッチの処理に必要な量だけを逐次 Tensor オブジェクトに変換し出力するという処理を行っており、下記のような実装になります。

# 元データをバッチで使用できる形式に変更する
label, image = tf.train.slice_input_producer([raw_data[0], raw_data[1]], shuffle=True, seed=1)
    
# データをエンキューしてバッチ化する
labels, images = tf.train.batch([label, image], batch_size=batch_size)

いずれにせよ、このミニバッチの結果出力される labels と images は Tensor 型のオブジェクトとなるため、http://ksksksks2.hatenadiary.jp/entry/20160718/1468833883 のように一から自身で TensorFlow で使えるようにしたデータとほぼ同じように使用することができます。

"ほぼ”という条件付きなのは、あらかじめ Session に関連付けた QueueRunner をデータの読み出しを行う前に起動しておく必要があるからです。とはいえ、tf.train.start_queue_runners を学習や評価の前に呼び出せばいいだけですので難しい話ではありません。呼び出してしまえば、意識しなくても毎回適当なデータ組を読みだしてくれるため大変便利に使うことができます。

次に、CNN にはかかせない Convolution 層、Pooling 層、正規化層の使い方についてです。とはいえこれも全然難しくなく、tf.nn.conv2d、tf.nn.max_pool、tf.nn.lrn 関数を利用して実装していくだけとなります。それぞれ、2次元画像用のConvolution、Max Pooling、Local Response Normalization を実現するための層となります。ちなみに LRN はドキュメントには記載がありませんが、 C++ で記述されているコアコードにはしっかり定義があるので使えなくなることは無いと思われます。Convolution層の重みの初期値を設定するために関数を独自実装していますが、これは重みのL2ロスをバッチのロスに加えるためのヘルパー関数となります。

以上で段取りは完了です。あとはGPUマシンで学習を実行し、5,6時間待っていただければ精度85%くらいの識別器の完成です。

TensorFlow Basic CNN

TensorFlow の ptb サンプルを動かす

TensorFlow で ptb を学習させるサンプルは Recurrent Neural Networks チュートリアルに記載されている通り、 github からソースを落としてきて、tensorflow/models/rnn/ptb に移動し、ptb_word_lm.py を動かすだけで簡単に動作させることができます。

ただし残念なことに、サンプルコードをぱっと見ただけで使い方を理解するのは相変わらずなかなか難しいです。API にのっていないクラスや関数が使われたり、RNN 特有の処理がさくっと書かれているため、サンプルとしてまあ不親切なわけです。

そこで今回も前回の DNN と同様、自己流にサンプルを書き直して使い方を確認してみました。書き直したコードを動作させてみて、だいたい元のコードと同じような性能が出ていそうなので、ざっくりと解説をしてみようと思います。

いつもどおり完成コードは、記事の最後の方に置かせていただいています。書き直したコード内の内部で reader ファイルは元サンプルの reader と全く同じものを利用しています。

また、RNNをまともに学習させようと思うとCPUでは非常に遅いので、動作確認には AWSGPU インスタンスを使用しています。

TensorFlow ってどうやって使うの?AWSGPUインスタンスでどうやって動かせばいいの?という方は、まずは過去記事をご参照ください。

ハイパーパラメーターと入出力用変数

さて、手法のコードを書く前にイニシャライズをする必要がありますが、DNN の場合だいたいここでハイパーパラメーターの設定と入出力用のデータを定義します。TensorFlow で書く場合もその流儀にならって書くと下記のようになります。

# config
self._batch_size = 20
self._num_steps = 2
self._hidden_size = 2
self._vocab_size = 10000
self._num_layers = 1
self._keep_prob = 0.5
self._max_grad_norm = 1

# input and output variables
self._input_data = tf.placeholder(tf.int32, [self._batch_size, self._num_steps])
self._targets = tf.placeholder(tf.int32, [self._batch_size, self._num_steps])
self._initial_state = None
self._final_state = None
self._cost = None
self._train_op = None
self._logits = None

バッチサイズなどがハイパーパラメーターで、input_data などが PlaceholderVariable などの入出力用の変数となります。Placeholder も Variable も TensorFlow で計算の時に使用される変数クラスですが、Placeholder が入力用、Variable は最終出力および中間出力用に主に使用されるものでしたね。

RNN で大事なものは、内部状態をいつまで保持するかを定義している num_steps と内部状態を表す変数である initial_state と final_state です。この2つの値に注目して以降のコードを見ていきましょう。

LSTMの利用

続いて、LSTMを利用して、次の単語を出力させる手順までを見てみましょう。損失関数の定義やパラメーター更新の方法は通常のDNNと大差ありませんので省略させていただきます。

# LSTM
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(self._hidden_size, forget_bias=0.0, state_is_tuple=True)
# add dropout
if is_training:
    lstm_cell = tf.nn.rnn_cell.DropoutWrapper(lstm_cell, output_keep_prob=self._keep_prob)
# add multi lyaers
cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * self._num_layers, state_is_tuple=True)
# initial state setup
self._initial_state = cell.zero_state(self._batch_size, tf.float32)

ここから先のコードは色々と不親切で全然サンプルになっておりませんので心して追っかけていきましょう。

まず、LSTM の基本クラスである tf.nn.rnn_cell.BasicLSTMCell が早速API一覧にのっていません。詳細が気になる方は、TensorFlow ソースコード内の tensorflow/python/ops/rnn_cell.py をご参照ください。使い方自体はそんなに難しくはなく、隠れ変数のサイズと忘却率、そして state_is_tuple という値を指定しているだけで LSTM セルを定義できてしまいます。

state_is_tuple は元のサンプルコードでは使用されていませんが、使用しないままコードを動かすと、state_is_tuple が False だと遅いし False の場合はそのうち Duplicated だからね!という警告 が r0.9 の時点では表示されます。このオプションは、LSTM の計算時に入出力される隠れ変数を Variable クラスのタプルとして表現するかどうかを示すものになります。

書き換えるだけで早くなるのであれば書き換えない手はありませんが、evaluation の時に独特な処理が必要となりますのでそこだけご注意ください。下記のコードの run_epoch 関数を参考にするとわかりやすく汎用的に書き換えることができますのでご参照ください。

続いて用いられているのが、tf.nn.rnn_cell.DropoutWrapper と tf.nn.rnn_cell.MultiRNNCell です。この2つは見たまんまなのですが、LSTM の入力にドロップアウトを適用する処理と、LSTM + Dropout を複数個並べてくれる処理になります。

使用している引数も、DropoutWrapper の場合はベースとなるLSTMセルとキープレート、MultiRNNCellの場合は組み合わせるセルの配列と上記に登場した state_is_tuple を指定しています。

最後に、RNNCell クラスの zero_state という便利関数を利用して、隠れ変数の初期値を表す Placeholder クラスを取得します。この値はのちのちの計算処理で必要になるので確実に保持しておく必要があります。

# Load predefined layer "embedding"
with tf.device("/cpu:0"):
    embedding = tf.get_variable("embedding", [self._vocab_size, self._hidden_size])
    inputs = tf.nn.embedding_lookup(embedding, self._input_data)

# Add dropout after embedding layer
if is_training:
    inputs = tf.nn.dropout(inputs, self._keep_prob)

次に、単語IDを単語ベクトルに変換する処理を行います。ここでもなかなか TensorFlow を作っている人でないと普通わからないだろうという処理を行っていまして、tf.get_variable で "embedding" という変数を取得しています。どうやら "embedding" という変数が Word Embedding 用にすでに用意されているらしく、その変数を使って単語IDをベクトルにする処理を行っているようです。仕様書読むだけでは分かりませんね。

ちなみに rnn_cell.py には入力を単語ベクトルにした後、RNN セルに適用してくれる EmbeddingWrapper クラスが存在しています。試してみていませんが多分同じような結果になると思われます。

# Calculate LSTM Layer for in _num_steps
outputs = []
state = self._initial_state
with tf.variable_scope("RNN"):
    for time_step in range(self._num_steps):
        if time_step > 0: tf.get_variable_scope().reuse_variables()
        (cell_output, state) = cell(inputs[:, time_step, :], state)
        outputs.append(cell_output)

次に、LSTM を利用した計算の肝となるシーケンスの処理部分を見てみましょう。今回のインプットデータは、ミニバッチ × シーケンス長(num_steps) × 単語ベクトル という形の配列として作成されています。ミニバッチ単位でベクトルを計算していく点は他の DNN と変わりありませんが、RNN ではシーケンシャルなデータの処理を行う必要があります。

LSTM のような隠れ変数がある層では、truncate という隠れ変数をリセットし、バックプロバケーションを打ち切る長さを決めておく必要があります。この長さはもちろん可変でも良いのですが、それではミニバッチの利用に向かず処理が遅くなるため、このサンプルでは固定長とされています。

さてこの truncate 処理ですが、それ用の関数などはなく、上記のように自前で実装する必要があります。とはいっても見ての通りで num_steps 数分、一個ずつ入力データをずらして RNN セルに入力していっているだけです。注意点としては、後の評価やパラメーター更新に使用するため、出力される変数はなんらかの形で保持しおく必要がある点くらいです。

# Final output layer for getting word label 
output = tf.reshape(tf.concat(1, outputs), [-1, self._hidden_size])
softmax_w = tf.get_variable("softmax_w", [self._hidden_size, self._vocab_size])
softmax_b = tf.get_variable("softmax_b", [self._vocab_size])
self._logits = tf.matmul(output, softmax_w) + softmax_b

最後に、出力を単語ID に変換するための通常の全結合層を挿入して終了です。先ほど取得した num_steps 数分の出力を全て処理してやらなければならない点がややこしいですが、注意すべきはそこくらいとなります。このあと損失関数を定義し、最適化関数をはさんで Session.run を実行すれば学習は完了です。

予測された次の単語を取得する処理も、logits をミニバッチおよびステップ毎に argmax などで候補となる単語IDに変換してやればOKです。rnn_cell.py の中身を熟読すればもっとシンプルに書けそうですね。

TensorFlow basic RNN sample

AWS の GPU インスタンスで TensorFlow を動かしてみた(2016.07)

前回は TensorFlow のチュートリアルを触ってみたわけですが、当然のごとく手元のノートPCではさほど速度を出すことができません。DNNをあつかう宿命としてGPU上で動作させることは避けては通れないものです。

というわけで、GPU で TensorFlow を動かすために AWSインスタンスをたてようと試みたわけですが、Chainer の時のようにさくっとは行かず。。。

どうやら依存している CUDA のバージョンの関係で、AWSNVIDIA インスタンスでは動作させることができないようです。じゃあ適当なインスタンスに CUDA 入れればいいだけじゃんと油断したのが裏目に出てしまい、色々と手こずってしまったので、個人的な備忘録としてGPU インスタンスで TensorFlow を動作させるまでの手順を残しておきたいと思います。

TensorFlow ってどういうことができるのって方は、まずは下記の記事をお読みの上で以降に進まれることをおすすめします。

前提

今回利用したもののバージョン等は下記のようになります。

cuDNN をインストールするには、NVIDIA のサイトから利用申請をしておく必要がありますので、処理を進める前に早めに完了しておくことをおすすめします。 以降は、TensorFlow のDownload and SetupOptional: Install CUDA (GPUs on Linux) を元に進めていきますので、もしバージョンが変わって必要な処理が変わっている場合は、リンク先の情報に従って処理を行うことをおすすめします。

前準備

処理に必要なもののインストールおよびモジュールのアップデートを行います。Python 3.4 の場合は最低限必要な下記をインストールしておいて貰えば十分です。

sudo apt-get update
sudo apt-get upgrade -y
sudo apt-get install python3-dev python3-pip git -y

CUDA のインストール

最初で最後のハマりポイントと言っても過言ではありません。ここで、特に何も考えずに言われる通りに CUDA をインストールしてしまうとえらい目に合います。Nouveau をブラックリストに入れ、CUDA と一緒にインストールされる NVIDIA ドライバと衝突しないようにしてやる必要があります。 Nouveau を無効にするにあたって下記の記事を参考にさせていただきました。

Nouveau の無効化は上記の記事のものをそのまま利用して、以下の処理を実行することで行うことができます。

echo -e "blacklist nouveau\nblacklist lbm-nouveau\noptions nouveau modeset=0\nalias nouveau off\nalias lbm-nouveau off\n" | sudo tee /etc/modprobe.d/blacklist-nouveau.conf
echo options nouveau modeset=0 | sudo tee -a /etc/modprobe.d/nouveau-kms.conf
sudo update-initramfs -u
sudo reboot

sudo apt-get install -y linux-image-extra-virtual
sudo reboot

上記で Nouveau を無効化後、下記を実行することで、Ubuntu x64 環境向けの CUDA 7.5 をインストールすることができます。ビルドに必要となる Linux ソースのインストール以外は、CUDA のダウンロードサイトに記載されている内容をそのまま実行しているだけですので、手順が変更されている場合は、そちらに記載の方法をまず実行することをおすすめします。

sudo apt-get install -y linux-source linux-headers-`uname -r`

wget http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1404/x86_64/cuda-repo-ubuntu1404_7.5-18_amd64.deb
sudo dpkg -i cuda-repo-ubuntu1404_7.5-18_amd64.deb
sudo apt-get update
sudo apt-get install cuda -y

※ 2016/10/8 追記 なぜかネットワークインストーラでは最新のCUDAが入ってしまい、TensorFlow がうまく動かない事があるようです。 少々サイズが必要になりますがローカルインストーラをダウンロードしてきてCUDAをインストールすることをおすすめします。

インストール完了後、nvidia-smiコマンドを実行し下記のように出力されれば CUDA のインストールは成功です。

nvidia-smi

+------------------------------------------------------+                       
| NVIDIA-SMI 352.93     Driver Version: 352.93         |                       
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GRID K520           Off  | 0000:00:03.0     Off |                  N/A |
| N/A   38C    P0    38W / 125W |     11MiB /  4095MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID  Type  Process name                               Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+

cuDNN のインストール

cuDNN のインストールは、CUDA のインストールパスに cuDNN 用のファイルを配置することで実現できます。あらかじめ cuDNN のページから Linux 向けの cuDNN v4 をローカルにダウンロード後、scp でインスタンスのホームにファイルを配置しておいてください。あとは、Optional: Install CUDA (GPUs on Linux)を参考にファイルを配置すればOKです。

tar xvf cudnn-7.0-linux-x64-v4.0-prod.tar
sudo cp cuda/include/cudnn.h /usr/local/include
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64/

※ 2016/10/8 追記 TensorFlow のバージョン 0.10.0 以降では、cuDNN の ver.5.x が推奨となっていますので、そちらをインストールすることをおすすめします。

TensorFlow のインストール

最後は、TensorFlow をインストールして完了です。Download and Setupを参考に pip で Python3.4 向けにインストールする処理は下記のとおりです。他のバージョンや環境でインストールする場合は、その場合の処理が記載されていると思いますので、そちらを参考に行ってください。

export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/gpu/tensorflow-0.9.0-cp34-cp34m-linux_x86_64.whl
sudo pip3 install --upgrade $TF_BINARY_URL

インストール完了後、~/.bash_profile などに下記の(Optional, Linux) Enable GPU Support に記載の通りに、GPUを利用するためのおまじないを記載して実行すれば完了です。

export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/usr/local/cuda/lib64"
export CUDA_HOME=/usr/local/cuda

動作確認

これでインストールは完了です。ちゃんとインストールされているかをTest the TensorFlow installationにそって確認してみましょう。

まずは、GPU を使用する設定がちゃんと動作するかを確認します。下記のコマンドを実行して、CUDA をロードしているようなログが出れば成功です。

python3 -c 'import os; import inspect; import tensorflow; print(os.path.dirname(inspect.getfile(tensorflow)))'

I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcublas.so locally
I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcudnn.so locally
I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcufft.so locally
I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcuda.so locally
I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcurand.so locally
/usr/local/lib/python3.4/dist-packages/tensorflow

続いて処理をちゃんと行えているかを見てみましょう。チュートリアルにそって MNIST の CNN モデルをロードする処理で確認します。下記のコマンドを実行後、Found device 0 with properties:のようなログが出ていれば GPU をロードして処理が行われています。

python3 -m tensorflow.models.image.mnist.convolutional 

I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcublas.so locally
I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcudnn.so locally
I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcufft.so locally
I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcuda.so locally
I tensorflow/stream_executor/dso_loader.cc:108] successfully opened CUDA library libcurand.so locally
Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
Extracting data/train-images-idx3-ubyte.gz
Extracting data/train-labels-idx1-ubyte.gz
Extracting data/t10k-images-idx3-ubyte.gz
Extracting data/t10k-labels-idx1-ubyte.gz
I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:924] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
I tensorflow/core/common_runtime/gpu/gpu_init.cc:102] Found device 0 with properties: 
name: GRID K520
major: 3 minor: 0 memoryClockRate (GHz) 0.797
pciBusID 0000:00:03.0
Total memory: 4.00GiB
Free memory: 3.95GiB
I tensorflow/core/common_runtime/gpu/gpu_init.cc:126] DMA: 0 
I tensorflow/core/common_runtime/gpu/gpu_init.cc:136] 0:   Y 
I tensorflow/core/common_runtime/gpu/gpu_device.cc:806] Creating TensorFlow device (/gpu:0) -> (device: 0, name: GRID K520, pci bus id: 0000:00:03.0)
Initialized!
Step 0 (epoch 0.00), 9.4 ms
Minibatch loss: 12.054, learning rate: 0.010000
Minibatch error: 90.6%
Validation error: 84.6%

最後に、チュートリアル外ですがちゃんと速度がでるようになったかを確認しましょう。今回は、TendorFlow のコードに付属している CIFA のサンプルコードで確認を行っています。下記のように学習を実行すると、minibatch 単位で学習過程をログに流してくれます。g2.2xlarge ではだいたいbatch あたり 0.2 sec で学習を進めてくれるようになります。

git clone https://github.com/tensorflow/tensorflow
cd tensorflow/tensorflow/models/image/cifar10/
python3 cifar10_train.py

TensorFlowでDNNをスクラッチするためのオレオレチュートリアル

はじめに

Chainer もなんとなしに慣れてきたので(使いこなせているレベルではありませんが)、他のDNN Framework も触ってみようと思いたち、昨日からTensorFlowをいじってみています。 最終的なアウトプットは同じなので、クラス構造などが結構似通っていて、思ったより学習コストが低かったのですが、一点苦戦したのがTensorFlowのチュートリアルの微妙さです。

以上...!

といった感じで、普通のDNNはどう書いたらいいの?な質問に答えてくれるのにぴったりなコンテンツが残念ながらありません。 Easy ML with tf.contrib.learn あたりが求めているものに近いのですが、tf.contrib.learn という3分クッキング用モジュールを使用しているため、汎用性のある使い方を知ることができません。

仕方がないので自力でどうにかするしかないかということで、tf.contrib.learn Quickstart を tf.contrib.learn モジュールを一切使用せずに置き換えたチュートリアルを作ってみました。

ゴール

tf.contrib.learn Quickstart に掲載されている、アイリスデータを3つの中間層を持つDNNで学習し精度と予測結果を出力するコードを、tf.contrib.learn モジュールを一切使用せずに置き換えます。

イメージとしては、元のコードとほとんど同じ形式で処理を呼び出し、同じ結果が得られるようなコードを実装していきます。

def main(args):
    # Load datasets.
    x_train, y_train = load_csv(filename=IRIS_TRAINING)
    x_test, y_test = load_csv(filename=IRIS_TEST)

    # Build 3 layer DNN with 10, 20, 10 units respectively.
    classifier = Classifier(hidden_units=[10, 20, 10], n_classes=CLASS_SIZE)

    # Fit model.
    classifier.fit(x_train, y_train, steps=200)

    # Evaluate accuracy.
    accuracy_score = classifier.evaluate(x_test, y_test)[0]
    print('Accuracy: {0:f}'.format(accuracy_score))

    # Classify two new flower samples.
    new_samples = np.array([[6.4, 3.2, 4.5, 1.5], [5.8, 3.1, 5.0, 1.7]], dtype=float)
    y = classifier.predict(new_samples)
    print ('Predictions: {}'.format(str(y)))

ひとまず完成品はTensorFlow basic DNNに掲載してありますので、コード読めばわかるという方はそちらをどうぞ。

TensorFlowのバージョンはr0.9、実行環境はMac x64 の CPUになります。基本的なことしかしていないので、環境やバージョンを変えても動くとは思います(思いたいです)。

データの読み込み

まずは、必要なデータの読み込みを行っていきましょう。クイックスタートのコードはここでさっそく専用のcsvロード関数を使用しています。

とはいえやっていることは簡単で、読み込んでいるアイリスデータのcsvの書き方に依存してはいますが、下記のように読み込んだデータを説明変数群と目的変数とに分離しているだけです。データのヘッダ部分はサンプル数および説明変数の数が記載されているので、データ配列を初期化するために読み込む必要があります。

def load_csv(filename):
    file = pd.read_csv(filename, header=0)

    # get sample's metadata
    n_samples = int(file.columns[0])
    n_features = int(file.columns[1])

    # divide samples into explanation variables and target variable
    data = np.empty((n_samples, n_features))
    target = np.empty((n_samples,), dtype=np.int)
    for i, row in enumerate(file.itertuples()):
        target[i] = np.asarray(row[-1], dtype=np.int)
        data[i] = np.asarray(row[1:n_features+1], dtype=np.float64)
    return (data, target)

DNNモデルクラスの作成

データは問題なく読み込むことができたと思うので、ここから最も重要なモデルクラスを実装していきましょう。TensorFlow にはモデルのベースとなるようなクラス(Chainer の Chain クラス等)のようなものはありませんが、使い方が分かってしまえば特に苦労せず使いまわしやすい実装を行うことができます。

上記のクイックスタートのような処理を行うには、学習と予測、精度算出ができればよいので、早速1つずつ実装していきましょう。

学習モデルの作成

学習を始める前に必要なのは学習モデルを構築することです。TensorFlowではVariableクラスを作成して、それぞれの Variable オブジェクトのリンク関係を定義することによりモデルを構築していきます。3つの中間層を持つDNNは下記のようなコードで表現することができます。

また、Placeholderと呼ばれる学習データを扱うための変数を定義する必要があり、下記のコードでは引数xがそれに当たります。

簡単にコードを説明していきましょう。見たまんまなのですが、入力層の後、3層の中間層、softmax出力層のあるDNNを定義しています。いずれも入力値xに重みWをかけバイアスbを足して活性化関数を通したあとに次の層に渡すという構成になっています。活性化関数は中間層の第一層は恒等関数、第二層と第三層はReLU、出力層はsoftmaxを使用しています。

重みやバイアスを定義する際に使用している tf.truncated_normal や tf.zeros は変数初期化用に用意されている関数で、numpy の初期化関数のように使うことができます。tf.truncated_normal のstddev を求めるための get_stddev 関数は元のコードと結果が近くなるように tf.contrib.layers.initializerz を参考に実装しています。効率良く学習するための変数初期化方法の例がのっていますので、興味がある方は眺めてみることをオススメします。

name_scope の内側で各層の変数を定義していますが、このことにより階層構造で内部に変数を記憶させることができます。

注意すべき点は、学習する際にバッチ単位で毎回下記の関数が呼ばれるわけではなく、Theano 等のようにあくまでこのコードではリンク関係を定義しているだけで、実際の計算自体は TensorFlow の内部で行われるということです。そのため学習途中のパラメーターを見たい場合は、下記のコードにprint文を追加することでは実現できず、Summary クラスを利用して観測するなど独特な方法で実現する必要があります。

def inference(self, x):
    hidden = []

    # Input Layer
    with tf.name_scope("input"):
        weights = tf.Variable(tf.truncated_normal([IRIS_DATA_SIZE, self._hidden_units[0]], stddev=get_stddev(IRIS_DATA_SIZE, self._hidden_units[0])), name='weights')
        biases = tf.Variable(tf.zeros([self._hidden_units[0]]), name='biases')
        input = tf.matmul(x, weights) + biases

    # Hidden Layers
    for index, num_hidden in enumerate(self._hidden_units):
        if index == len(self._hidden_units) - 1: break
        with tf.name_scope("hidden{}".format(index+1)):
            weights = tf.Variable(tf.truncated_normal([num_hidden, self._hidden_units[index+1]], stddev=get_stddev(num_hidden, self._hidden_units[index+1])), name='weights')
            biases = tf.Variable(tf.zeros([self._hidden_units[index+1]]), name='biases')
            inputs = input if index == 0 else hidden[index-1]
            hidden.append(tf.nn.relu(tf.matmul(inputs, weights) + biases, name="hidden{}".format(index+1)))

    # Output Layer
    with tf.name_scope('output'):
        weights = tf.Variable(tf.truncated_normal([self._hidden_units[-1], self._n_classes], stddev=get_stddev(self._hidden_units[-1], self._n_classes)), name='weights')
        biases = tf.Variable(tf.zeros([self._n_classes]), name='biases')
        logits = tf.nn.softmax(tf.matmul(hidden[-1], weights) + biases)

    return logits

いざ、学習

学習モデルができたところで、いよいよ訓練データを使用して学習していきましょう。学習に必要なものは、学習データと損失関数と最適化アルゴリズムです。

まず損失関数から見ていきましょう。損失関数はlossとして実装しています。出力値とラベルのベクトルの各行の積をとり、バッチ内での平均値を返す仕組みになっています。tf.reduce_mean は TensorFlow 内で Reduction と呼ばれる関数群の一つで、テンソルの各次元単位で平均を求めることができます。今回は何も指定していないので、全ての値の平均値を返すようになっています。

続いて、本丸のfit関数を見ていきましょう。最初にやっているのは、学習データを格納するための Placeholder の定義です。shapeの1番目は、バッチ学習用の次元なのでサイズを None に指定しています。次に、定義した Placeholder を上記で作成した学習モデルに通すことで結果が、結果と正解ラベルを損失関数に通すことで損失値が求められるというリンク関係を定義しています。最後に、SGDを使用して損失値が最小化するように学習させるという学習用オペレーションを定義して準備は完了です。

準備が完了したら、変数の更新や計算を行うための Session オブジェクトの用意です。Session オブジェクト自体はクラスの初期化時に作成するようにしていますので、ここでは Session オブジェクトを利用して定義済みの変数の初期化のみを行っています。

変数の初期化まで完了して、いよいよ学習処理を行うことができます。この処理では、指定されたstep回数分学習用オペレーションを実行します。この時、feed_dict に渡しているのは、Placeholder オブジェクトを Key に、実際に使用する学習データを Value に格納した辞書オブジェクトとなります。これにより、与えた学習データによる更新処理を一発で行ってくれます。

get_batch_data でバッチデータを作成しているように見せかけていますが、今のところ全てのデータを一回のバッチとして扱うような実装になっています。そのため、説明変数はそのまま、従属変数もカテゴリ値を 1-of-N なベクトルに変換して返す処理のみを行っています。

一部の Variable オブジェクトをクラス内変数に保存していますが、これは評価用関数でも使い回すための手順なので学習には直接関係ありません。(使いわすための方法としてこれが最適なのかも微妙です。もっと良い書き方がある気がします。)

def loss(self, logits, y):        
    return -tf.reduce_mean(y * tf.log(logits))

def fit(self, x_train=None, y_train=None, steps=200):
    # build model
    x = tf.placeholder(tf.float32, [None, IRIS_DATA_SIZE])
    y = tf.placeholder(tf.float32, [None, CLASS_SIZE])
    logits = self.inference(x)
    loss = self.loss(logits, y)
    train_op = tf.train.GradientDescentOptimizer(0.5).minimize(loss)

    # save variables
    self._x = x
    self._y = y
    self._logits = logits

    # init parameters
    init = tf.initialize_all_variables() 
    self._sess.run(init)

    # train
    for i in range(steps):
        batch_xs, batch_ys = get_batch_data(x_train, y_train)
        self._sess.run(train_op, feed_dict={x: batch_xs, y: batch_ys})

テストデータによる評価

最後にテストデータによる評価に必要な関数を実装していきましょう。テストデータによる正解率の算出とクラス識別を行っていますが、いずれも上記の学習処理内で保存した変数を利用していることに注意してください。x は説明変数、yは目的変数、_logitsはモデルからの出力を表す変数として、それぞれ定義していました。その変数をそのまま流用していますので、このリンク関係をそのまま利用することができます。

識別用の関数が分かりやすいのでそちらから見ていきましょう。識別関数では、出力層の3つのノードからもっとも値の大きいノードを取得しています。この処理を tf.argmax で生成した Variable オブジェクトが、Session.run 関数で入力に指定されたデータを渡した時にどのような値になるかを計算することにより求めています。

正解率の算出用関数も要領は同じです。正解率を求める過程と結果の Variable オブジェクトを定義し、テスト用データでその値を求めるという構造になっています。

上記で行ったモデルの学習も含め、TensorFlowでは、変数のリンク関係を定義し、求めたい変数と計算に用いる入力値を Session.run 関数に渡すことによりその変数の値を計算することができます。

def evaluate(self, x_test=None, y_test=None):
    x_test, y_test = get_test_data(x_test, y_test)

    # build accuracy calculate step
    correct_prediction = tf.equal(tf.argmax(self._logits, 1), tf.argmax(self._y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # evaluate
    return self._sess.run([accuracy], feed_dict={self._x: x_test, self._y: y_test})

def predict(self, samples):
    predictions = tf.argmax(self._logits, 1)
    return self._sess.run(predictions, {self._x: samples})

おわりに

以上で、TensorFlow を利用した基本的なDNNの作成は完了です。あとはモデルの定義をCNNやRNNに変更したり、損失関数を変更したり、最適化アルゴリズムを変更するだけで使いまわせるんじゃないかと思います。一覧性が微妙なAPIドキュメントという障害もありますが、ここまでこれば余裕ですよね!

ちなみにパラメーターや学習状況を観測したい場合は、TensorBoard機能を利用すれば良いようですので、興味のある方は僕に教えて下さい。

参考

GoogleのAIはどうやって「詩」を生成するのか

一ヶ月ほど前ですが、Google人工知能が「詩」を創りだしたという話が話題になりました。

wired.jp

この話の元ネタは、[1511.06349] Generating Sentences from a Continuous Spaceで発表されている論文になります。この論文では、ベイズとDeep Learningを組み合わせた生成モデルを使用して、文章のコンテキスト情報から文章を生成する手法を提案しています。この提案手法は2つの文章の間の文章を生成することも可能で、記事で紹介されている「詩」はそのようにして生成されたものの一つになります。

この記事では、上記の論文で提案されているアルゴリズムの導入から、それを利用してどのように「詩」を生成するかを解説していきたいと思います。

この論文の肝は、VAE(Variational Autoencoder:変分オートエンコーダ)を利用して、文章のオートエンコーダーをモデル化しているところです。エンコーダーでは文章のコンテキスト情報を潜在変数として出力し、デコーダーではこの潜在変数をもとに文章を生成するというモデルとなっています。

VAEは、観測変数から潜在変数を推論するモデルと、その逆の潜在変数から観測変数を生成するモデルを、別々に等しくなるように学習する確率モデルとなります。この確率モデルのパラメーターの決定は、ニューラルネット等により行うことも可能で、この論文でもニューラルネットを使用して学習しています。

VAEの基礎は変分ベイズ法で、潜在変数から観測変数を生成するモデル{p_{\theta}(z)p_{\theta}(x|z)}とその事後分布{p_{\theta}(z|x)}を変分近似する{q_{\phi}(z|x)}を考えます。データに対して逐次学習を行い、周辺尤度の変分下界を最大化することを目標に、適当なパラメーター{\theta}{\phi}が得られるようにニューラルネットを学習していきます。

VAEの学習手順は、(私の理解が正しければ)下記のとおりです。

  1. 観測変数{x_i}を用いて、ニューラルネットでパラメーター{\phi}を求める
  2. パラメーター{\phi}を用いて、{q_{\phi}(z|x)}から{z_i}をサンプリングする。
  3. 観測変数{z_i}を用いて、ニューラルネットでパラメーター{\theta}を求める
  4. 周辺尤度{p_{\theta}(x)}の変分下界をもとに{\theta}{\phi}の勾配を求める
  5. パラメーターの勾配を元にニューラルネットワークの更新を行う
  6. 飽きるまで繰り返す

※ サンプリングの方法とか勾配の計算方法の詳細は、元論文著者のPPTを参照ください。

あとはVAEを使って計算するだけかとおもいきや、シーケンシャルなデータを扱う手前そういうわけにはいきません。 論文では、VAEの前と後ろにRNNを配置するVRAE(Variational Recurrent Autoencoder)と類似のモデルを使用しています。VRAEでは、エンコーダーの最終出力を用いて、確率分布のパラメーターを推定し、そのパラメーターを使用して確率分布から潜在変数をサンプリングします。サンプリングされた潜在変数は、デコーダーの一回目の入力として使用されます。

VRAEの学習手順は、(こちらも私の理解が正しければ)下記のとおりです。

  1. エンコーダーに系列データを入力し{x_i}を求める
  2. {x_i}からVAEの方法にそって{z_i}を求める
  3. デコーダーに{z_i}を一回目の入力とし、誤差を求めつつ順次系列データを入力する
  4. 誤差からデコーダーのRNNを更新する
  5. VAEのニューラルネットのパラメーターをVAEの手順にそって更新する
  6. {z_i}を用いて{q_{\phi}(z|x)}から{x_i^{'}}を求める
  7. エンコーダーのRNNを更新する
  8. 飽きるまで繰り返す

提案されているモデルでは、VRAEとは異なり、エンコーダーにもデコーダーにも一層のLSTMを使用したRNNを用いています。また確率分布としては、生成モデルにも推論モデルにも正規分布を使用しています。さらに、学習時にはKLダイバージェンスの項にパラメーターを導入したり、潜在変数を用いたデコードを強化し不完全な文章に強くするため、わざとデコーダーに入力する文章を歯抜けにするなどの工夫を行っています。

上記の記事で紹介されている詩は、文1をエンコードして得られた潜在変数{z_1}と文2をエンコードして得られた潜在変数{z_2}から求めた{ z(t) = z_1 \ast (1-t) + z_2 \ast t}をデコードすることにより生成します。式からわかるように、{z(t)}{z_1}{z_2}を結ぶ線分上に存在するいずれかの点になります。

下の記事で紹介されている例を見ると分かりやすいですが、この{z(t)}を用いてデコードした文章は、文章構造やトピックが2つの文章に類似したものとなります。一方、このモデルで得られる潜在変数が獲得している情報は、あくまで一つの文章内での文章構造や単語の使われ方のみのため、文意にそって総合的な文を生成するということまでは残念ながらできていまいません。

www.gizmodo.jp

ここまで読んでいただければおわかりかと思いますが、このモデルは詩を生み出そうとして作られたものではなく、トピックや文章構造に焦点を当てて文章を生成するモデルを学習した結果、生成される文章群の特徴上「詩」のような文章が生成されるという結果となっています。(論文には詩という言葉は一言も出てきません。)

一方、論文の成果を利用する立場から見ると、ベクトルの演算により2つの文章の中間っぽい表現が得られることは、分散表現を用いて処理を行う上では使い勝手が良く興味深い結果ではないかなと思います。このモデルにより得られたベクトルをさらに違うモデルにくわせることにより、文意を組んだ文章全体を生成するようなモデルを学習することもできるのではないか、期待してみていきたいところです。

参考