Auto-KerasでKaggle:Digit Recognizer（Mnist）を試す

引き続きKaggleのDigit Recognizer（Mnist）を試しています。少しでもスコアを上げようとハイパーパラメータを調整しては提出を繰り返していましたが、このハイパーパラメータ調整を自動化してくれるAuto-Kerasというライブラリがあったので試してみることにしました。

基本的には数行のコードでMnistなどの画像分類をしてくれます（以下）。

from keras.datasets import mnist
from autokeras.image_supervised import ImageClassifier

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(x_train.shape + (1,))
x_test = x_test.reshape(x_test.shape + (1,))

clf = ImageClassifier(verbose=True)
clf.fit(x_train, y_train, time_limit=12 * 60 * 60)
clf.final_fit(x_train, y_train, x_test, y_test, retrain=True)
y = clf.evaluate(x_test, y_test)
print(y)

内部の細かい仕組みについては検証していませんが、これでモデルやバッチサイズなど自動的に決めてくれるようです。いくつかのモデルやハイパーパラメータを試して、結果論的にベストなものを選ぶという感じでしょうか。

ということで、上記サンプルをKaggleのデータに置き換えて試してみました。
訓練用データを訓練と検証用データに分けて、メモリーの限度を超えないように、dtypeをint64からuint8に変換しています。

結果を得るためには、fit()内のtime_limitで時間設定する必要があるようです。とりあえず1時間試してみると、結果は0.98738で0.99には届きませんでした（前回のCNNで0.99528）。デフォルトでは24時間になっているので、もう少し長い時間かけたほうがいいのかもしれません。


まとめ：
以前ベイズ最適化（ハイパーパラメータチューニングのアルゴリズム）を試してみましたが、こんな短いコードで済んでしまうのは便利です。Mnistの場合は手動でハイパーパラメータを調節してもそれなりの結果（スコア：0.99以上）が出せますが、未知のモデルに対するベースラインをとりあえず出してみるときにいいのかもしれません。
ただし、最低でも数時間は回し続けなければいけないので、途中でエラーがでてしまうとまたやり直しというのが面倒です。
autokerasの場合は完全自動化なので、特定のハイパーパラメータを自動化できるGpyOptを使ったベイズ最適化も試してみたいと思います（こちらの例とか）。

参考にしたサイト：
https://www.simonwenkel.com/2018/08/29/introduction-to-autokeras.html

Kaggle：その２（Titanic、Mnistなど）

前回のTitanicの続きです。
いろいろとハイパーパラメータを調節して目標としていたスコア：0.80（上位8%）を何とか超えることができましたが、どうも乱数固定が不安定で偶然出てきた結果という感じ。たぶんCUDAとともにインストールしたcuDNNのほうで乱数の固定ができていないような。まあ、それでもできるだけ固定することでわずかな誤差ですむようになってきました。以下が現在の乱数固定方法。このほかKerasのDense層のkernel_initializer、Dropoutにおいてもseedを固定しています。


スコアをあげるための決定的な解決策はまだ出てきていないのですが、今回はKerasのEarlyStopping機能（訓練ループを自動的に止める）を使ってみました。

EarlyStoppingだけでなく、自動的に学習率を下げるReduceLROnPlateauとModelCheckpointでベストなウェイトを保存させて、その結果から予測させています。要はできるだけ自動化という方向で。

提出結果のスコアを比較していくと、隠れ層を1層にした非常にシンプルなニューラルネットのほうがいい結果が出ました。Titanicの場合はデータ数が少ないので（訓練＋テスト：1309サンプル）、優れた予測モデルを構築しにくいのかもしれません。乱数の違いでもかなり結果が変わってしまうのでその辺が難しそう。

基本的にはデータをみながらの工夫はせずに、数値化したデータをそのままニューラルネットに渡して自動的に解決する方法にしています。

それぞれのデータに関しては：

Pclass：そのまま
Name：含まれるTitle（Mr/Mrsなど）を抽出し数値化（0〜17）、正規化
Sex：数値化、male:0, female:1
Age：欠損値あり（後で穴埋め）、正規化
SibSp：正規化
Parch：正規化
Ticket：削除
Fare：欠損値あり（後で穴埋め）、正規化
Cabin：欠損値も含め数値化：nan:0, C:1, E:2, G:3, D:4, A:5, B:6, F:7, T:8に変換
Embarked：欠損値あり（後で穴埋め）、数値化：S:0, C:1, Q:2

何度かスコア：0.80を超えた（上位8%）のですが、あまり当てにならないので、再度仕切り直しで以下のコード（スコア：0.78947）。

表示されない場合はこちら。

Digit Recognizer（Mnist）：
Titanicはまだまだやり続けたいのですが、1日に10回までしか提出できないので、ビギナー用のDigit Recognizerも試してみました。これはサンプルでよく使われているMnist（手書き文字）。
基本的にCNNを通して10通りの数字を分類しますが、これまで精度を上げてみるということはしたことがなかったので、どの程度できるのか今回チャレンジ。

よくあるCNNでやってみてもスコア：0.99以上にはなりました。あとは0.001でもいいのでより精度をあげるにはどうしたらいいかという感じです。
結果としては、0.99528（上位18%）まで上げることができました。以下がコード。

表示されない場合はこちら。

サンプルなどでよくあるCNNに対して層やユニット数を調整したり、BatchNormalizationやDropoutを加えてみました。最初は0.993くらいでしたが、その分やや向上しました。
この他、画像をリサイズしてKeras ApllicationsにあるXceptionやInceptionV3なども試してみましたが、それほど良い結果は得られなかったので、そんなに層を増やさなくてもよさそうです。
これもまだまだ精度をあげることはできそうなので、もう少しやり込みたいと思っています。


TGS Salt Identification Challenge：
この他、賞金ありのコンペにも試しに登録してみました。これは地質画像をもとに塩の埋蔵量を予測するコンペのようです。Kernelsには基本的なアルゴリズムがのっているので、そのままコピペしてベースラインのスコアは得られますが、そこからさらに精度をあげなければいけません。基本的に画像認識のコンペですが、セグメンテーションするためのU-net、intersection-over-union（IoU）、その離散値を連続値として計算可能にするLovasz Hinge Lossというテクニックが使われているようで難しそうです。
期限前までに完全理解することはできませんでしたが、Kernelsを読んでいるだけでも勉強になるので、難しそうでも一度参加してみて、できるところまでやってみると知見も広がってよさそうです。

Kaggleで勝つデータ分析の技術

posted with amazlet at 19.11.04

門脇 大輔 阪田 隆司 保坂 桂佑 平松 雄司
技術評論社
売り上げランキング: 363

Amazon.co.jpで詳細を見る

Kaggle：TitanicをKerasで試してみる

いつかはKaggle（機械学習コンペサイト）をやってみようと思っていましたが、今回ようやくチャレンジしてみました。練習もかねて、ビギナー向けの「Titanic」から。

「Titanic」は訓練データを元に、テストデータの乗客者の生存確率を予想するコンペです。ビギナー向けなので締め切りはないようです。現在は1日10回まで提出できるようです（結果のスコアが分かる）。
もうすでに10000チーム以上がエントリーしてあり、100%の予想方法もあるようですが、今回はあまり難しい方法は使わず、単純にKerasでニューラルネットを組んでどのくらいの確率になるか試してみることにしました。

Googleアカウントで登録可能で、コンペにエントリーすればデータのダウンロードができます。

提出用ファイルの書式サンプルもあるので、それに従ってcsvファイルを書き出せばいいようです。提出は以下の画面からドラックアンドドロップでも可能（Step 1）で、すぐに結果を知ることができます。Step 2は任意のメモ欄で、パラメータの設定値などをメモしています（後で編集可）。

結果を提出すれば、以下のようにすぐにScore（右端）が出てきます。

この提出結果は0.75119なので、いまいち。

Kernels:
KaggleにはKernelsと呼ばれる、解析手順のアイデアやアルゴリズムが参加者によって挙げられています。これを参考にみていくと、どのようにこのデータを扱っていけばいいのかわかります。

使うデータは：
train.csv
test.csv
の二つだけで、最終的にはtest.csvの乗客者リストの生死を0/1で予想します。

データを読み込むと、

PassengerId
Survived
Pclass
Name
Sex
Age
SibSp
Parch
Ticket
Fare
Cabin
Embarked

という項目にわかれて数値や文字列が出てきます。
直接生死に関係のないデータも含まれていますが、どの項目を重視し、あるいは捨ててしまうかはその人次第です。
しかし厄介なのは、たまにデータが抜け落ちており（欠損値）、それを捨てるか、それとも何かを手がかりに穴埋めするかも決めなくてはなりません。まずは一つずつチェックしていかなければならないのですが、Pandas（データ用ライブラリ）をつかえばこのような作業も比較的簡単にできます。

Kernelsを見ると、それぞれの項目の相関を表にしたり、事前にいろいろとデータの傾向を見ているようです。
データサイエンティストではないので、今回はこのような手続きはスキップしてKerasのニューラルネットで自動的に予測してみたいと思います。

そのためには、多少データを整理する必要があります。
・不必要と思われる項目を捨てる
・データに含まれる文字列を数値化
・必要に応じて数値を正規化/標準化
・欠損値を埋める

Pandasをそこまで使いこなしていないので、今回はPandasの勉強もかねてデータクリーニングするところから開始という感じです。

ベースライン：
一応ベースラインというものがあるようで、性別を根拠に求めると0.76555にはなるようです。その他の要素をつっこんでも0.77990が限界という人もいるようです。どうも0.80000を超えるのは難しいようで、なにかしらの工夫が必要なのかもしれません。ということで、とりあえずはベースライン以上を目指してみようかと。

Kaggleで勝つデータ分析の技術

posted with amazlet at 19.11.04

門脇 大輔 阪田 隆司 保坂 桂佑 平松 雄司
技術評論社
売り上げランキング: 363

Amazon.co.jpで詳細を見る

事前準備：
あとでAge, Embarked, Fareの欠損値を穴埋めするために、以下のような事前準備。
・train.csvとtest.csvを合体
・Ticketの項目を捨てる

文字列を数値へ変換：
・NameからTitle（MrやMissなど）を抜き出す
・Titleに番号を割り振る（0〜17）、合計18種類
・Sexをmale:0, female:1へ変換
・Cabinをnan:0、C:1, E:2, G:3, D:4, A:5, B:6, F:7, T:8へ変換（欠損値:0）
・Embarkedをnan:nan, S:0, C:1, Q:2へ変換（欠損値はあとで穴埋め）

これで、train.csvとtest.csvの両方を数値化（欠損値以外）完了。train.csvとtest.csvを合わせて合計1309人分のデータになります。

数値の正規化あるいは標準化：
特にAgeとFareは他の項目よりも数値が大きいので、場合によっては正規化あるいは標準化が必要かも。

データを欠損値の有無で分ける：
Age, Fare, Embarkedに欠損値があるので、これらを穴埋めするために分けておきます。そうすると、1309人中1043人分のデータが欠損値なしになります。

欠損値補完：
欠損値を穴埋めする際には
・0で埋める
・平均値で埋める
・頻度の高い数値で埋める
などいくつか方法があるようですが、今回は欠損値もニューラルネットで予想しようと思います。

ここまで準備するにも結構時間がかかりました。おかげでPandasの使い方にも慣れてきました。

Kerasで穴埋め用ニューラルネットモデルを構築：
とりあえず、層の数、ユニット数などは適当に決めて、あとから調整してみたいと思います。Embarked、Fare, Ageという欠損値の少ない順に求めてみました。


生存者予想：
nanを穴埋めしたデータを元に、train.csv（891人）からtest.csv（418人）の生存者を0/1で予想します。これもまたKerasのニューラルネットを使って予想します。

結果：
とりあえず一回目の結果としては0.71770でした。かなり低い。しかし、エラーはでないので一応アルゴリズムとしては間違ってはいなさそうなので、ここから改良していこうかと。


改良：
ニューラルネットの層をいろいろ変えてみると、層を増やしてもあまりいい結果がでないので浅くしてみました。少し改善されて0.74641。
batch_sizeをデフォルトの32から5に変えると0.75598

しかし、テストデータ418人中100人以上が間違っているということなので、ちょっとしたランダムな誤差でも数人分かわってしまいそう。このあたりになってくると、もはやゲームのハイスコア狙いのような感覚になってきます。

さらにBatchNomalizationやDropoutなども層に追加してみたり、いろいろ試してみました。しかし0.75前後という感じで0.80まではなかなか届きそうにありません。複雑にしたからといっても正解率があがるわけでもなく、精度の低いモデルにオーバーフィッティングしているだけなのかもしれません。

要素を減らして（Pclass, Sex, Age, Fare, Embarkedだけ）シンプルに計算してみると、0.77990まであがりました。ようやくベースライン。

その後、また要素は戻して、正規化で全ての数値を0.0〜1.0に変換し、比較的シンプルな層でやってみると今までのベストスコアとなる0.78947。約10000人中の3371位。半分より上に行けたのでよかったのですが、これも偶然という感じ。
random.seedによっても結果が変わりそうなので、

import tensorflow as tf
import random as rn
import os
os.environ['PYTHONHASHSEED'] = '0'
rn.seed(123)
np.random.seed(123)
session_conf = tf.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)
from keras import backend as K
tf.set_random_seed(123)
sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)
K.set_session(sess)

で乱数を固定してみました（Kerasの再現可能な結果）。
追記：
Dense()とDropout()のなかのkernel_initializerにも乱数の設定があるので、
kernel_initializer=keras.initializers.glorot_uniform(seed=123)
と固定してみましたが、GPUを使っているためかそれでも毎回微妙に値が異なってしまいます。cuDNNのほうも設定しないといけないのかもしれません。

まとめ：
Kaggle自体敷居が高そうですが登録や提出などは簡単で、何度も提出できるので気軽に参加できます。実際に具体的な目標（スコア）があるので工夫しがいがあります。ハマると、ゲーム感覚でハイスコアを狙うといったやりこみ癖が出てきそうです。そういう意味でも面白いかもしれません。勉強する際にサンプルコードを写経するだけでおしまいになることがありますが（動くかどうか確かめるだけ）、工夫によってスコアが変わるためいろいろ試しながら結果を比較向上していく部分がさらなる理解度を深めます。当然、データの事前処理も今まではあまりやったことはありませんでしたが、データのあり方から様々な傾向が見えてくるのも面白いと思います。

その後いろいろいじってみましたが、0.76前後をふらふらしており決定的な改善策が見当たりません。NameをTitleに変換し、さらにTitleをone-hotラベルに変換したりしましたがそれほど効果なし。欠損値をニューラルネットで予測し、その予測を元に最後の生死を予測しているので、最初の予測が間違っていれば意味がないという感じかもしれません。1日に10回まで提出することができるので何度も試しているところです。

以下が、現在のコード（Jupyter Notebook）。まだベースライン前後なので、もう少し改良が必要です。

Gistが表示されない場合はこちら。

Android上のPython：Pydroid 3, Jupyter Notebook, Colab

スマホでちょっとしたPythonのコードを確かめられないかと探してみると、Google PlayストアにPydroid 3というPython環境があったのでインストールしてみました。

 

pipを使うことが可能で、numpyやmatplotlibもインストール可能。ためしにサンプル（上画像）を実行させてみました。特に問題なく動きます。

pipでインストールする方法：

 

メイン画面の「≡（メニューマーク）」をタップすると、上画像左のような項目が出てくるので、「Pip」をタップすればライブラリを検索する画面になります。そして必要なライブラリ名を入力して「INSTALL」をタップ。

「QUICK INSTALL」タブには、主なライブラリがリストアップされているので、numpyやmatplotlibなどはこちらからインストールいたほうがいいかもしれません。インストールしたいライブラリが見当たらなければ「SEARCH LIBRARIES」タブで検索。

pipでJupter NotebookやKeras（Theano）をインストール：

pipの画面からKerasはインストール可能でしたが、Tensorflowは対応していないためかダメでした。そのかわりTheanoはインストールできたので、KerasのバックエンドとしてTheanoが使えます。

追記：

その後アップデート（2019年4月）があったようで、有償版にすればTensorflowもインストールできるようになっていました。

最近パソコンではJupyter Notebookばかり使っているので、スマホの方にもインストールしてみることにしました。

ターミナル画面からJupyter Notebookを起動：

基本は.pyファイルで保存ですが、Jupyter Notebookで.ipynbファイルも扱うことができます。

メニュー>Pipの画面から「jupyter」をインストールし、ターミナル画面に切り替えてから「jupyter notebook」を入力して起動すると、

 

Chromeが自動的に起動してJupyter Notebookの画面が出てきました。パソコンと同じような感覚で使うことができます。Chromeが自動的に開かない場合は、ターミナル画面に出てくるURLをChromeのアドレスにコピペすればJupyterの画面になるはずです。

あまり重い演算はさすがに無理ですが、ふと思いついたコードを試すにはよさそうです。

Android 7と8での違い：

Android 7では上記の方法でJupyter Notebookは動作しましたが、Android 8の場合だとセキュリティの違いのためかChromeが自動的に起動しません。ターミナル上に出力されたアドレスをChromeへコピペするしかありません。

追記：

その後のアップデートでAndroid 8でも自動的にChromeが立ち上がるようになっていました。

問題なのが、Jupyterが起動したあとPydroidのカーネルが途中で落ちてしまいます。マルチウィンドウ（二窓）でChromeとPydroidを起動しておけば落ちないのですが、Chromeを前面表示するとバックグラウンドで動いているPydroidが数秒で落ちてしまいます（対応策は下へ追記しました）。

このようにChrome（Jupyter）とPydroidを上下に同時に表示させて使う分にはPydroidのカーネルが落ちずに済みます。キーボード（画像ではフローティングにしていますが）は下のほうにでるので、Pydroidのターミナル画面に重なる感じならJupyter画面にもあまり邪魔にならないかと。

画面移行してしまうとPydroidが落ちてしまいますが、再度ターミナルでJupyterを起動し、Chromeのほうは画面をこのまま再読み込みさせれば大丈夫そうです（再度アドレスをコピペする必要がない）。

追記（上記の対応策：Huawei Nova lite 2の場合）：

Android 8のバッテリー最適化機能でカーネルが落ちないようにするには、「設定」→「アプリと通知」→「アプリ」から画面下の「歯車」の設定マークをクリック→「アプリの設定」→「特別なアクセス」→「バッテリー最適化を無視」の画面で「すべてのアプリ」を表示させ「Pydroid 3」を一覧から選択し「許可」するに変更。

こうすることでバッテリー最適化によるアプリの自動切断を防ぐことができ、バックグラウンドでも動き続けるようです。

Jupyter nbextensionsのインストール：

Jupyter Notebookを使う場合、nbextensionsをインストールすれば様々な機能拡張が使えるようになります。

Pydroidのpip画面で

jupyter_contrib_nbextensions

を入力（あるいは検索）してインストール。

さらにターミナル画面に切り替えて、

jupyter contrib nbextension install --user

を入力（インストールはこれで終了）。

ターミナル画面から「jupyter notebook」入力で、ChromeにJupyterを立ち上げます。

 

そうすると「Nbextensions」というタブが増えているので、それを選択すればさまざまな機能拡張の一覧が出てきます。

「Nbextensions」タブがない場合は、「localhost:8888/nbextensions/」にアクセスすれば出てくるはずです。

Gist itを使う：

個人的に便利だと思うのはGithubのGistへボタン一発でファイル保存する機能です。

「Nbextensions」の一覧を見ていくとでてくるので、「Gist-it」にチェックをいれておきます。

 

そして、コーディングするページを開けば、

 

右上にGithubマークのボタンが増えているので（現れなければ画面をリロード）、これをクリック。

そうすると確認画面がでてくるので、青い「Gist it!」ボタンでアップロード（Tokenを登録する必要があります）。プライベートでアップロードしたいなら「Make the gist public」のチェックを外しておきます。

ファイルの保存先を忘れることもなく、後でパソコンからアクセスするのも容易なので便利です。

オンラインのJupyter Notebookを使う：

https://jupyter.org/にアクセスすればインストールせずにオンラインでもJupyterを試すことができるようです。

 

Jupyterのトップページ上の「Try it in your browser」をタップすれば、JupyterかJupyterLabなどを選択するページへ移動し、とりあえず「Try Jupyter with Python」をタップすると「Welcome to Jupyter」というサンプルページが表示されます（以下）。

 

左上の「≡Menu」から「File>Open...」を選べばディレクトリ一覧のページが表示されます。

ここで右上の「New▼」から「Python3/Text File/Folder/Terminal」を選択して新たなファイルを開くことができます。

Terminalを選択すればターミナル画面に移行し、「pip list」入力でインストールされているライブラリを確認できます。Numpy、Scikit-learn、Scipy、Pandasなど基本のライブラリはインストールされているようです。TensorflowやKerasはインストールされていませんが、「pip install tensorflow」で追加インストールできるようです。

ファイルも一時的に保存できるようですが、仮想サーバのためか、一旦ログアウトしてしまうとすべては消えてしまうようです。

ちょっとしたコードを試すだけなら、このオンラインのJupyterでも十分そうです。

関連：Binder：オンライン上でのJupyter Notebook（ipynbファイル）の実行

Google Colabをスマホ上で使う：

Jupyter Notebookが使えるのは便利ですが、それならGoogle Colabを使えばいいのでは？ということでColabも試してみました。Colabの場合は全ての環境はクラウド上にあるので、ChromeさえあればスマホからでもGPU利用が可能です。Tensorflow、Keras、Numpy、Pandas、Matplotlibなど基本的なライブラリはすでにインストールしてあるUbuntu環境なので便利。

この場合、先ほどのPydroid 3は無関係で、単にChromeでcolab.research.google.comへアクセスすればいいだけ。

特に問題なく動きます。基本Google Driveにデータファイルなどを保存しておけば便利です。Colabの場合ならTensorflowも普通に使えるし、GPU演算なのでスマホでも問題ないという感じ。

仮想キーボードCodeBoard Keyboard for Coding：

コーディングするには、Google PlayにあるCodeBoard Keyboard for Codingが便利そうだったのでインストールしました。

既存のキーボードだと、数字や記号を入力する際に入力切替が必要だったりアローキーがなかったりするため少々不便なのですが、このキーボードであればコーディングに必要そうなキーが揃っているので便利です。コメントアウトの「#」記号だけ表面にないのですが、右上「SYM」を押せば記号一覧の中に出てきます。

まとめ：

Pydroid 3はスマホアプリなので一旦ダウンロードすればオフライン（通信料なしで）でも動く点では便利です。Tensorflowが使えなかったり、重い計算は無理なので多少の制約はあります。通信料が気になる場合はPydroid 3がいいかもしれません。ただしライブラリをインストールしすぎると1GBを超えたりするのでメモリを圧迫したくない場合は要注意。

一方、Colabの場合はコマンドのやりとりで通信料は発生しますが、演算自体はクラウド上（GPUでも可）で行うのでスマホであっても問題なく重い計算が可能という点が便利。また、ログインごとに（90分放置すると初期化）ライブラリやデータをインストールし直すのが面倒ですが、Google Driveに保存してあるデータをアップロードするのであれば、データのやりとりもクラウド上で行うのでデータが大きくてもその分の通信料はかからないはず。Colabを利用することで、スマホからでも普通にディープラーニングのコードを実行できるのはかなり画期的。Wifi環境下で通信料がかからないのであればColabがおすすめ。

データ分析ツールJupyter入門

Posted with Amakuri at 2018.12.21

掌田津耶乃

秀和システム

販売価格 ￥3,024

Amazonで詳細を見る

SCHOOL OF AI: MOVE 37（無料強化学習コース）

Siraj Raval氏のAI関係のYoutube動画はよく見るのですが、9/10から無料のコース「MOVE 37」が始まったので試しに登録してみました。内容は主に強化学習についてであり、10週で完了するコースです。

去年まではGANなどの生成的ネットワークにトピックが集中していたような気がしますが、最近は強化学習が流行ってきたのでしょうか？Pose Estimatorのようなアルゴリズムも公開され、ディープラーニングの応用法においても幅が広がってきたのかもしれません。


この「MOVE 37」というコースにおいては、以下を使って学ぶようです。

・Pytorch
・OpenAI Gym
・Google Collaborator
・TensorFlow

Google Colab上でコーディングし無料GPUで訓練できるので、どんなパソコンでも大丈夫という感じです。

コース内容は、1週間ごとに以下の項目を実施（合計10週）。

・Markov Decision Processes 0/7

・Dynamic Programming 0/7

・Monte Carlo Methods 0/6

・Model Free Learning 0/7

・RL in Continuous Spaces 0/7

・Deep Reinforcement Learning 0/7

・Policy Based Methods 0/7

・Policy Gradient Methods 0/7

・Actor Critic Methods 0/7

・Multi Agent RL 0/7

基本から始まり、一通り強化学習を順を追って勉強していくので、全体を網羅するにはいいのかもしれません。

1週目は「マルコフ決定過程」についてですが、

・強化学習の基礎知識（ビデオや文章）

・ミニテスト

・OpenAIのインストール

・Google Dopamine（Google最新の強化学習フレームワーク）の紹介

などです。

2週目（来週）から本格的にコーディングしていくという感じでしょうか。

無料コースなので、それほど親切丁寧に指導してくれるというわけではなさそうですが、Forumなどもあるので、聞きたいことがあれば誰かが答えてくれるといった環境はあります。そもそも強化学習に興味あるけど、どのような順番で何を勉強していけばいいかという手がかりは最低限得られるので、その後独学する手立てにもなると思います。

Google Colabの無料GPUで強化学習（Keras-RL）を試す

最近は、Google Colabの無料GPU（連続12時間まで）を使用して演算が可能なので、機械学習用GPUが搭載されていないパソコンでも充分機械学習の訓練などできそうです。使い方はオンラインのJupyter Notebookという感じです。

Colabスペック：
Ubuntu17.10（現在は18.04）
Intel(R) Xenon CPU @2.3GHz
13GB RAM
GPU NVIDIA Tesla K80

スペックはこんな感じ。アルゴリズムにもよりますがTesla K80がどのくらい高速なのかが気になります。自前のゲーミングノートはPascal世代のGTX1060ですが、K80はそれよりも2世代前のKepler世代のGPUのようです。
!nvidia-smiを打ち込むと以下。

このほか、機械学習に必要な基本的なライブラリはnumpy、pandas、matplotlib、Tensorflow、Kerasも含め既にインストールしてあるようです。Pytorchは入っていないのでインストールする必要があります（追記：その後Pytorchなどもインストール済みになったようです）。

ということで、前回のKeras-RL + Open AI Gym Atariの訓練（1750000ステップ）を比較してみようかと。自前のゲーミングノートGTX1060では約3時間かかりました。


インストール：
とりあえず、Keras-RLやGymなど必要なものをapt-get installやpipで前回同様にインストールする必要があります。

!pip install gym keras-rl pyglet==1.2.4
!apt-get install -y cmake zlib1g-dev libjpeg-dev xvfb ffmpeg xorg-dev python-opengl libboost-all-dev libsdl2-dev swig
!pip install 'gym[atari]'

最初に「!」マークをつけたあとpipやapt-getなどでインストールできます。今回は上記のものをインストールしました。前回Jupyterの際、pyglet1.3.2だとダメだったので、最新ではないpyglet1.2.4をインストールしています。
必要なライブラリなどはインストールできますが、再度ログインするとまたインストールし直さないといけないようです（Colab内は毎回クリアされる？）。


実行時間の比較：
以下が自前のGTX1060での訓練時のログ。これは前回Jupyter用に書き直したAtariブロック崩しの訓練です。

10000ステップで約60秒かかっています。訓練するには合計1750000ステップあるので、約3時間ということになります。

これに比べて、Google Colab（Tesla K80）の方は以下。

10000ステップで約108秒かかっています（意外と遅い）。

自前のゲーミングノート（GTX1060）のほうが1.8倍速いという計算になります。

とはいっても普通のMacBook（CPU演算）に比べればはるかに速いとは思います。

しかしながら、370000ステップの途中で突然ストップしてしまいました。

最後に、「Buffered data was truncated after reaching the output limit」という表示が出ています。何か出力限界に達したようで、途中停止しています。

検索してみると、Stack flowに似たような件について書いてありました。RAMかGPUのメモリをオーバーしてしまったようで、バッチサイズを少なくするか、小分けに途中経過（ウェイト）を保存しておいて再開するかなどの工夫が必要そうです。一応プログラム上ではチェックポイントを設けて250000ステップごとにウェイトを途中保存してはあります。

やはりある程度の規模になると、使用する上での工夫が必要そうです。今回の場合だと1750000ステップの訓練をさせるには概算すると5時間はかかりそうです。連続使用12時間以内で済みそうですが、それ以前にメモリなども気を遣わなければいけないということです。

ということで、処理速度を知りたかったので訓練は途中で終了。

動画表示：

そのかわりに、以前保存しておいたウェイトを読み込んでColab上に表示できるか試してみました。

尚、外部ファイルなどを読み込ませるには以下を書き込んでランさせるとファイル選択ダイアログがでてきて、パソコンの任意の場所からファイルを読み込むことができます。

from google.colab import files
uploaded = files.upload()

前回Jupyter上で表示可能であった方法を試してみましたが、画面のちらつき、動画としての更新速度が非常に遅く、いまいちという結果。

ということから一旦出力画像を非表示にして、matplotlibのArtistAnimationに変換後表示する方法を試してみました（以下）。

from rl.callbacks import Callback
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML
%matplotlib inline

ims = []

class Render(Callback):
    def on_step_end(self, step, logs={}):
        im = plt.imshow(env.render(mode='rgb_array'))
        ims.append([im])

weights_filename = 'dqn_{}_weights.h5f'.format(ENV_NAME)
dqn.load_weights(weights_filename)

callbacks = Render()
fig = plt.figure(figsize=(4,5))
plt.axis('off')
dqn.test(env, nb_episodes=1, visualize=False, callbacks=[callbacks])

ani = animation.ArtistAnimation(fig=fig, artists=ims, interval=10)
# ani.save("anim.gif", writer = "imagemagick")  # imagemagick for Ubuntu
plt.close()

HTML(ani.to_jshtml())         # JavascriptHTML output
#HTML(ani.to_html5_video())   # HTML5 Video output

これは前回もJupyter上で試した方法です（前半の訓練時のコードは省いてあります）。一旦画像は非表示にして、Keras-RLのCallback関数をオーバーライドして表示用サブクラスをつくっています（詳しくは前回参照）。Keras-RLはdqn.test()で別窓に動画表示してしまうので、それを非表示にしておき、Jupyter上で表示可能なデータに変換してから表示しています。
結果的には、アニメーションとして最後表示することができました。Jupyterも表示には手こずりましたが、Colabはオンラインでもあるためどうしてもリアルタイムだと遅くなってしまうようで、このようにアニメーションとして変換してしまえば問題なさそうです。アニメーションに変換する分、少しだけ（数十秒程度）余計に時間がかかりますが、特に目立った遅さではないのでこれでいけそうです。

アニメーションとして保存してあるので、オンラインによるタイムラグはなく普通に速く動きます。
Atariの場合はこのようにColab上に表示されますが、CartPoleのようなClassic controlの場合はレンダリングの仕組みが違うためかColab上のアニメーションだけでなく別窓にも表示されてしまいます。

追記：尚、このボタン付きアニメーションをWebページに埋め込むには以下。
Matplotlib Animation embed on web page：アニメーションのWebページ上への埋め込み


まとめ：

結果的には自前のゲーミングノートGTX1060のほうが速かったのですが、数時間かかりそうな訓練の場合にはGoogle Colabのほうで処理させておき、メインのパソコンではまた別の作業をという感じで使うこともできそうなので、それなりに便利かと。

今後はこのようなGPUのクラウドサービスが主流となってくれば、機械学習をするにはわざわざゲーミングパソコンを買うまでもないかと思います。ネットだけできればいいような5万円前後のGoogle Notebookでもいいのかもしれません。

機械学習スタートアップシリーズ Pythonで学ぶ強化学習 入門から実践まで (KS情報科学専門書)

posted with amazlet at 19.11.04

久保 隆宏
講談社
売り上げランキング: 115,841

Amazon.co.jpで詳細を見る

Keras-RLで強化学習/DQN(Deep Q-Network)を試してみる

前回GANについて理解を深めてみましたが、その後もGANの発展型となるACGANやInfoGANについても引き続き勉強中です。しかしながら、今回はやや方向転換して強化学習（Reinforcement Learning）について試してみました。

環境：
Ubuntu 18.04
GTX 1060
CUDA 9.0
python 3.6
tensorflow 1.9
Keras 2.1.6
Keras-rl 0.4.2
Jupyter Notebook 5.6


アルゴリズム：
強化学習には独特のアルゴリズムが使われており、ディープラーニング以前にも

・Q-Learning
・SARSA
・モンテカルロ法

などが基本としてあるようです。
その後、AlphaGOで有名となった

・DQN（Deep Q-Network）

そして、さらに改良された

・Double DQN
・Dueling DQN
・AC3
・UNREAL
・PPO

などがあるようです。日々改良されているようですが、どれがいいのかは目的によっても異なるようです。とりあえず今となってはDQNあたりが基本かと。


OpenAI：
手っ取り早く強化学習を勉強するならOpenAIのGYMを利用するとよさそうです。GYMには倒立振子やATARIのビデオゲームなどの教材があり、強化学習アルゴリズムを書き足せばすぐに試すことができます。
このページのインストール方法に従って必要なライブラリなどをインストールしますが、ATARIのビデオゲームを使いたい場合はcmakeも必要となるので、Ubuntuであれば一通り以下のコマンドで全てインストールしておいたほうが良さそうです。

apt-get install -y python-numpy python-dev cmake zlib1g-dev libjpeg-dev xvfb ffmpeg xorg-dev python-opengl libboost-all-dev libsdl2-dev swig

動作チェック：
Getting Started with Gymにも書いてありますが、以下のコードで100ループ動きます（ランダムな動き）。ちなみにこのままだとJupyter Notebookでは表示（レンダリング）されないので、.pyファイルにして実行させないといけません。

import gym

env = gym.make('CartPole-v0')
env.reset()

for _ in range(100):
    env.render()
    env.step(env.action_space.sample())
env.close()

あっというまに表示が終わってしまうので以下のようにtime.sleep()でディレイを加えてみました。

import gym
import time

env = gym.make('CartPole-v0')
env.reset()

for _ in range(100):
    env.render()
    env.step(env.action_space.sample())
    time.sleep(0.02)
env.close()

Jupyter Notebookの場合：
アニメーションをJupyter Notebook上で表示するには少し工夫が必要です。stack overflowにもいくつか方法が書いてあります。
ATARIの場合であれば以下の方法で表示可能でした。

import gym
from IPython import display
import matplotlib.pyplot as plt
%matplotlib inline

env = gym.make('Breakout-v0')
env.reset()

img = plt.imshow(env.render(mode='rgb_array'))

for _ in range(100):
    img.set_data(env.render(mode='rgb_array'))
    display.display(plt.gcf())
    display.clear_output(wait=True)
    action = env.action_space.sample()
    env.step(action)
env.close()

しかし、CartPole-v0のようなClassic controlの場合だとエラーがでてしまうので、インストールしてあるpyglet1.3.2を一旦アンインストール（pip uninstall pyglet）して、pyglet1.2.4をインストール（pip install pyglet==1.2.4）し直すといいようです（こちらの方法）。ただこの方法だとJupyter上だけでなく別窓も開いてしまいます。そして、env.close()を最後に書き加えないと、別窓を閉じることができなくなるので要注意。

別窓だけの表示でいいのであれば（Jupyter上には表示させない）、pyglet1.2.4にダウングレードさえしておけば、以下の方法でも可能でした。

import gym
import time

env = gym.make('CartPole-v0')
env.reset()

for _ in range(100):
    env.render()
    env.step(env.action_space.sample())
    time.sleep(0.02)
env.close()

Jupyter Notebook上に表示させる方法をいろいろ探してみましたが、別窓での表示であれば簡単そうなので、以下のKeras-RLでも別窓表示にすることにしました。


Keras-RL：
とりあえずDQNで強化学習をしたいので、どの機械学習フレームワーク（Tensorflow、Keras、Pytorchなど）を使えばいいかということですが、Keras-RLというKeras向けの強化学習用のライブラリがあり、以下のようなアルゴリズム（ここに書いてある）が既に搭載されており、すぐに使うことができます。

Name	Implementation	Observation Space	Action Space
DQN	rl.agents.DQNAgent	discrete or continuous	discrete
DDPG	rl.agents.DDPGAgent	discrete or continuous	continuous
NAF	rl.agents.NAFAgent	discrete or continuous	continuous
CEM	rl.agents.CEMAgent	discrete or continuous	discrete
SARSA	rl.agents.SARSAAgent	discrete or continuous	discrete

複雑なアルゴリズムをコーディングしなくても、既存の関数にパラメータを渡せば計算してくれますが、基本となるQ-Learningの仕組みはある程度理解しておいたほうがよさそうです。
Action Space欄に離散値か連続値かの違いがあるので、目的に応じて使い分けるといいと思います。


DQNを試してみる：

CartPoleのサンプル：
Keras-RLにはいくつかのサンプルコードがあるので、dqn_cartpole.pyを試してみることに。
Jupyter NotebookでRunさせる場合は、別窓としてアニメーションが表示されます。終了後別窓を閉じるために、最後の行にenv.close()を追加しておきます。

import numpy as np
import gym

from keras.models import Sequential
from keras.layers import Dense, Activation, Flatten
from keras.optimizers import Adam
from rl.agents.dqn import DQNAgent
from rl.policy import BoltzmannQPolicy
from rl.memory import SequentialMemory

ENV_NAME = 'CartPole-v0'

env = gym.make(ENV_NAME)
np.random.seed(123)
env.seed(123)
nb_actions = env.action_space.n

model = Sequential()
model.add(Flatten(input_shape=(1,) + env.observation_space.shape))
model.add(Dense(16))
model.add(Activation('relu'))
model.add(Dense(16))
model.add(Activation('relu'))
model.add(Dense(16))
model.add(Activation('relu'))
model.add(Dense(nb_actions))
model.add(Activation('linear'))
print(model.summary())

memory = SequentialMemory(limit=50000, window_length=1)
policy = BoltzmannQPolicy()
dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=10,
               target_model_update=1e-2, policy=policy)
dqn.compile(Adam(lr=1e-3), metrics=['mae'])

dqn.fit(env, nb_steps=50000, visualize=True, verbose=2)
dqn.save_weights('dqn_{}_weights.h5f'.format(ENV_NAME), overwrite=True)

dqn.test(env, nb_episodes=5, visualize=True)
env.close()

GTX1060で、学習50000ステップ、約5分かかりました。
DQNAgentクラスに必要な項目を渡すだけなので、アルゴリズム的には超シンプルです。
CartPoleに関しては左か右に動かすだけなので、env.action_space.nは2になります。
最後のほうにあるdqn.save_weight()で学習したウェイトが外部保存されるので、次回このウェイトをつかってテストするには、以下のように書き換えることになります。

# 以下をコメントアウトして
# dqn.fit(env, nb_steps=50000, visualize=True, verbose=2)
# dqn.save_weights('dqn_{}_weights.h5f'.format(ENV_NAME), overwrite=True)

# かわりに保存したウェイトを読み込む
dqn.load_weights('dqn_{}_weights.h5f'.format(ENV_NAME))

dqn.test(env, nb_episodes=5, visualize=True)
env.close()

デフォルトでは、以下のように一回のepisodeでsteps: 200になっています。

例えばsteps: 500に変えるには、

env = gym.make("CartPole-v0")
env._max_episode_steps = 500

とすればいいようです（ここに書いてありました）。


ATARIブロック崩しをJupyter Notebook上に表示：
もうひとつは、ATARIのブロック崩しのサンプルです。これは (210, 160, 3) のRGB画像を入力としてCNNを通して学習していきます。画像から判断するので、どんなゲームでもいいということになります。サンプルにある通り1750000ステップ学習するために約3時間かかりました（GTX1060）。
もともとこのサンプルは.pyファイルですが、Jupyter Notebook上に表示できるように少し手を加えてみました。サンプルは最後の方にあるdqn.test()で結果表示されますが、既存コードを見るとenv.render(mode='human')が使用されており、Jupyter Notebook上に表示するにはenv.render(mode='rgb_array')に変換する必要がありそうです。
そのため、既存の結果表示はvisualize=Falseで非表示にし、かわりに自前のCallback関数を追加することで毎ステップ画像表示させることにしました。またargparseはJupyterでは使えないので消去し、そのかわりに各変数を用意しました。

from PIL import Image
import numpy as np
import gym

from keras.models import Sequential
from keras.layers import Dense, Activation, Flatten, Convolution2D, Permute
from keras.optimizers import Adam
import keras.backend as K

from rl.agents.dqn import DQNAgent
from rl.policy import LinearAnnealedPolicy, BoltzmannQPolicy, EpsGreedyQPolicy
from rl.memory import SequentialMemory
from rl.core import Processor
from rl.callbacks import FileLogger, ModelIntervalCheckpoint


INPUT_SHAPE = (84, 84)
WINDOW_LENGTH = 4

class AtariProcessor(Processor):
    def process_observation(self, observation):
        assert observation.ndim == 3
        img = Image.fromarray(observation)
        img = img.resize(INPUT_SHAPE).convert('L')
        processed_observation = np.array(img)
        assert processed_observation.shape == INPUT_SHAPE
        return processed_observation.astype('uint8')

    def process_state_batch(self, batch):
        processed_batch = batch.astype('float32') / 255.
        return processed_batch

    def process_reward(self, reward):
        return np.clip(reward, -1., 1.)

ENV_NAME = 'BreakoutDeterministic-v4'
env = gym.make(ENV_NAME)
np.random.seed(123)
env.seed(123)
nb_actions = env.action_space.n
input_shape = (WINDOW_LENGTH,) + INPUT_SHAPE

model = Sequential()

if K.image_dim_ordering() == 'tf':
    model.add(Permute((2, 3, 1), input_shape=input_shape))
elif K.image_dim_ordering() == 'th':
    model.add(Permute((1, 2, 3), input_shape=input_shape))
else:
    raise RuntimeError('Unknown image_dim_ordering.')

model.add(Convolution2D(32, (8, 8), strides=(4, 4)))
model.add(Activation('relu'))
model.add(Convolution2D(64, (4, 4), strides=(2, 2)))
model.add(Activation('relu'))
model.add(Convolution2D(64, (3, 3), strides=(1, 1)))
model.add(Activation('relu'))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dense(nb_actions))
model.add(Activation('linear'))
#print(model.summary())

memory = SequentialMemory(limit=1000000, window_length=WINDOW_LENGTH)
processor = AtariProcessor()

policy = LinearAnnealedPolicy(EpsGreedyQPolicy(), attr='eps', value_max=1., value_min=.1, value_test=.05,
                              nb_steps=1000000)

dqn = DQNAgent(model=model, nb_actions=nb_actions, policy=policy, memory=memory,
               processor=processor, nb_steps_warmup=50000, gamma=.99, target_model_update=10000,
               train_interval=4, delta_clip=1.)

dqn.compile(Adam(lr=.00025), metrics=['mae'])

# コールバックとJupyter表示用モジュールのインポート
from rl.callbacks import Callback
from IPython import display
import matplotlib.pyplot as plt
%matplotlib inline

# 表示用Renderサブクラス作成（keras-rlのCallbackクラス継承）
class Render(Callback):
    def on_step_end(self, step, logs={}):
        plt.clf()
        plt.imshow(env.render(mode='rgb_array'))
        display.display(plt.gcf())
        display.clear_output(wait=True)

MODE = 'train' # 'train' or 'test' 学習とテストのモード切替え

if MODE == 'train':
    weights_filename = 'dqn_{}_weights.h5f'.format(ENV_NAME)
    checkpoint_weights_filename = 'dqn_' + ENV_NAME + '_weights_{step}.h5f'
    log_filename = 'dqn_{}_log.json'.format(ENV_NAME)
    callbacks = [ModelIntervalCheckpoint(checkpoint_weights_filename, interval=250000)]
    callbacks += [FileLogger(log_filename, interval=100)]
    dqn.fit(env, callbacks=callbacks, nb_steps=1750000, log_interval=10000)

    dqn.save_weights(weights_filename, overwrite=True)
    # dqn.test(env, nb_episodes=10, visualize=False)
    
elif MODE == 'test':
    weights_filename = 'dqn_{}_weights.h5f'.format(ENV_NAME)
    dqn.load_weights(weights_filename)

    # 表示用コールバック関数を適用
    callbacks = Render()
    plt.figure(figsize=(6,8))
    dqn.test(env, nb_episodes=2, visualize=False, callbacks=[callbacks])

env.close()

元々のサンプルはargparseで'train'か'test'でモードの切り替えをしていましたが、かわりに変数MODEを用意して切り替えています（argparseの代わりにeasydictを使うといいようです）。
keras-rlのCallback関数をオーバーライドしJupyter用に表示用サブクラスをつくって、毎ステップごとにenv.render(mode='rgb_array')を呼び出して表示させています。keras-rlのCallbackクラスを見てみると、episodeやstepの前半後半のタイミングでコールバックできるようで、今回はstep後半のon_step_end()に表示機能を挿入しておきました。
この結果、一応Jupyter上には表示できるようになりましたが、plt.imshow()を使っているせいか動きが遅くなってしまいます。やはり別窓に表示させたほうがいいかもしれません。リアルタイムで表示させなくてもいいのであれば、以下の方法がいいかと。


Jupyter Notebook上にアニメーション表示とGIF動画保存：
matplotlibのArtistAnimationクラスで先程のブロック崩しを表示しつつ、GIF動画として保存する方法についてです。訓練後のテスト部分を少し変えて以下のようにしてみました。

from rl.callbacks import Callback
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML
%matplotlib inline

ims = []  # アニメーション用リスト

class Render(Callback):
    def on_step_end(self, step, logs={}):
        im = plt.imshow(env.render(mode='rgb_array'))
        ims.append([im])

weights_filename = 'dqn_{}_weights.h5f'.format(ENV_NAME)
dqn.load_weights(weights_filename)

callbacks = Render()
fig = plt.figure(figsize=(4,5)) # 出力画面サイズ調整
plt.axis('off')                 # 目盛り、枠線なし
dqn.test(env, nb_episodes=1, visualize=False, callbacks=[callbacks])

ani = animation.ArtistAnimation(fig=fig, artists=ims, interval=10)
# ani.save("anim.gif", writer = "imagemagick") # GIFアニメ保存する場合はコメントアウト
plt.close()

# Jupyter Notebook上にアニメーション表示
HTML(ani.to_jshtml())        # JavascriptHTML出力
#HTML(ani.to_html5_video())  # HTML5 Video出力（.mp4ファイルとしてダウンロード可）

サブクラスRender()内で予め用意しておいたアニメーション用リストに毎ステップ画像を追加していき、それをあとからArtistAnimationで動画にするという手順です。ArtistAnimationを使えばすぐにGIF動画として保存もできます。

Jupyter上のアニメーション表示としては2種類あり、JavascriptHTMLは動画速度を変えて再生も可能なので便利です（上画像）。またHTML5 Video出力のほうは表示画面から.mp4として動画をダウンロードできる機能がついています。
尚、matplotlibのArtistAnimationについては以前投稿したここを参照して下さい。

追記：尚、このボタン付きアニメーションをWebページに埋め込むには以下。
Matplotlib Animation embed on web page：アニメーションのWebページ上への埋め込み


まとめ：
OpenAIのGYMとKeras-RLを使うことで簡単にDQNを試すことができます。DQNに渡すパラメータについて理解しておけばいいという感じです。
このほか、二足歩行モデルがあるMuJoCo、ロボットアームやハンドマニピュレータがあるRoboticsのサンプルもあります。学習させるには結構時間かかりそうなので、まだ試してはいませんが、強化学習は生成モデルとはまた違ったアプローチをしている部分が興味深いという感じ。また、強化学習と生成モデルの組み合わせもできそうなので、アルゴリズム的に面白くなりそうです。
GPUがなくても、Google Colabを使えばこの程度の訓練であれば短時間でおわるかもしれません。

関連：
Google Colabの無料GPUで強化学習訓練を試す（Keras-RL）

機械学習スタートアップシリーズ Pythonで学ぶ強化学習 入門から実践まで (KS情報科学専門書)

posted with amazlet at 19.11.04

久保 隆宏
講談社
売り上げランキング: 115,841

Amazon.co.jpで詳細を見る