grbl1.1+Arduino CNCシールドV3.5+bCNCを使用中。
BluetoothモジュールおよびbCNCのPendant機能でスマホからもワイヤレス操作可能。
その他、電子工作・プログラミング、機械学習などもやっています。
MacとUbuntuを使用。

CNCマシン全般について:
国内レーザー加工機と中国製レーザー加工機の比較
中国製レーザーダイオードについて
CNCミリングマシンとCNCルーターマシンいろいろ
その他:
利用例や付加機能など:
CNCルーター関係:



*CNCマシンの制作記録は2016/04/10〜の投稿に書いてあります。


ラベル Kaggle の投稿を表示しています。 すべての投稿を表示
ラベル Kaggle の投稿を表示しています。 すべての投稿を表示

2019年1月11日金曜日

巡回セールスマン問題について

ここしばらくは「巡回セールスマン問題」について試行錯誤していました。きっかけは年末から開催されていたKaggleの「Traveling Santa 2018 - Prime Paths」コンペです(締め切り:2019年1月10日)。Kaggleでは年末恒例のイベントコンペのようで、一応賞金もでます(賞金総額:$25,000)。
ディープラーニングでは解けないようですが、面白そうなのでやってみることにしました(やってみれば得られることも多そうなので)。


巡回セールスマン問題(Traveling Salesman Problem/TSP):
TSPとは、地図上にある複数の都市をセールスマンが一筆書きのように移動して、その合計移動距離が最小になる経路を求めるアルゴリズムです。地図上の都市が少なければ(約20箇所以下)、移動順番の組み合わせを総当たりで計算し最短経路を探し出すことができますが、都市数が増えるほど組み合わせの数は爆発的に増えてしまい、スーパーコンピュータを使っても数万年かかってしまうようです。すべての組み合わせを計算することができないため、近似計算、最適化などの方法によって少しでも正解に近づくように工夫するようです。TSPサイト


今回のKaggleコンペルール:
基本はTSPにおける最短経路探索ですが、都市数は197769もあり、当然ながら総当たりで計算することが不可能。
都市名は0〜197768までのナンバリングされた数値であり、それぞれの都市には(X,Y)の座標値が割り当てられています。都市名0を開始点として都市間を移動し続け、最終的に巡回してまた0に戻るように都市の訪問順のリストをつくりあげて提出します。
さらに今回の特別ルールとして、都市から都市へ移動する際に、10ステップごとにペナルティが課されるときがあります。10ステップごとに一つ手前(9ステップ目)が素数の都市名であればペナルティなし、素数でない場合は9ステップ目から10ステップ目までの移動距離が1.1倍されてしまいます。要はできるだけ10ステップごとに9ステップ目が素数の都市名を通るように移動することが望ましいことになります。

実際どのくらいの都市数で、どのような経路になるかというと以下の画像のような感じです。
トナカイとソリの画像がそのまま都市の配置になっています。青い線が経路。これだけ都市数があるので、早々簡単には求められないということがわかります。


始めるにあたって:
まずTSPについては、一度は見たことがあるような問題ですが、詳しくは知らないのであくまでビギナーとして参加になります。調べていくとやはりTSPの研究者(数学者)がいるので、その人たちには到底敵いません。問題自体は至ってシンプルなのですが、解けそうで解けないという感じでしょうか。
KaggleのKernelsにはベースラインとなるコードが参加者によって掲示されているので、まずはそこをチェック。


TSP Solverライブラリ:
Kernelsを見るとTSP Solverというライブラリがいくつか存在し、それで計算すると総移動距離(スコア)が1533242前後になるようです。このスコアが少ないほど上位になるというわけです。多くの人は、このようなライブラリで数時間計算させベースとなる経路を得たのち、最適化アルゴリズムで少しづつ経路を調整してスコアを縮めていくようです。


アルゴリズム:
最適化アルゴリズムで少しずつスコアを縮めていくことはできますが、ある程度最適化してしまうと、それ以上スコアの変動はなくなってしまい手詰まりに陥ってしまいます。最初のTSPライブラリでかなりいいスコアを出しておかないときついという感じ。数日間連続計算させることでいい結果がでるときもありますが、今回はせいぜい一晩を上限としてプログラムを組んでみることにしてみました。組み合わせの問題でもあるので、組み合わせ数が多いほど有利になりますが、その分計算量も莫大になってしまいます。
とりあえずは、もう少しTSPの仕組みを理解しようとTSPライブラリを使わず自力でやってみることにしました。


欲張り法:
まずスタート地点から移動する際に、最も近い都市に移動し続けていけばいいのでは?と直感的に考えてしまいます。どうやら調べてみると、これは「欲張り法」というらしい。ということから、以下の関数が必要なので自前でつくることから始めてみました。

・二都市間の距離を測定する関数(単純距離)
・二都市間の移動経路のスコアを計算する関数(素数のペナルティも含め)
・ある都市に最も近い都市を求める関数(欲張り法用)


複素数で距離を求める:
(x1,y1)と(x2,y2)の二点間の距離を求めるには、

d = sqrt((x1-x2)**2 + (y1-y2)**2)

となりますが、pythonにおいては複素数がすぐに使えることから、y座標に1j(虚数)を掛けて各点を実部と虚部の一つの式にして計算できるようです。

p1 = x1 + y1*1j
p2 = x2 + y2*1j
d = abs(p1-p2)

都市が197768もあるので、順番に各都市との距離などを計算させると結構時間がかかります。できるだけ計算コストを抑えた工夫も必要そうです。上記の違いでどれだけ高速になっているかの検証はしていませんが、このような計算方法もあるというのが分かりました。


numbaで高速計算:
基本的にはnumpyで計算するためGPUを使えないことからどうしても計算が遅くなってしまいます。Kernelsを見ると、numbaを使えば高速計算や並行処理が可能になるらしく、慣れないながらも使ってみることにしました。numbaの最も簡単な使い方はdef関数前にデコレータとして@jitを追加させるだけです。

from numba import jit

@jit
def func(x):
  y = some_calculation...
  return y

このほかcudaを使う方法などもあるようですが、少々複雑なので今回は簡単な方法をできる範囲で使ってみることにしてみました。いずれにせよ、Kernelsからはこのような細かいテクニックが手に入るので結構勉強になります。


欲張り法の結果:
最短距離で繋いでいくので、そこそこいい結果がでるのではないかと期待していましたが、スコアは約1800000。TSPライブラリと比較すると約2割ほど多くなってしまいます。最初のうちは最も近い都市へ移動していくので効率的ですが、残りの都市が少なくなって行くに従って近くの都市も少なくなってしまうため、最短の都市であっても遠くの都市を選ばざるを得なくなってしまうからなのでしょう。

二方向の欲張り法:
欲張り法だと後半の都市選択が厳しくなってくることと、巡回ルートにしなければいけないことから、開始点から二方向に欲張り法でルートを繋げていくことにしてみました。一方が開始点からの順方向の移動で、もう一方が開始点までの逆方向の移動を最終的に中間地点でつなぐというやり方です。
しかしながらこの方法でもスコアは1800000程度で決定的といえるほど効果がありませんでした。単純に近い都市だけをつなぐだけだと進む方角の優先順位がないので、もう少し賢い方法が必要そうです。局所的に都市の分布密度が高い方へ優先的に移動するなどしたほうがよさそうですが、計算コストがかかりすぎるのでそこまではやらないことに。
ただ、あとからの最適化アルゴリズムでもスコアを縮めていくことは可能なので、とりあえず欲張り法で繋げておいてもいいのかもしれませんが、実際どうなのか(専門家ではないので分からない)?
このようにいろいろ試行錯誤しているとTSPの様々な問題が見えてきて、どうすればいいのか徐々に分かってきて興味も湧いてきます。


最適化アルゴリズム:
TSPライブラリであれ欲張り法であれ一旦経路をつくってから、それを調整していくアルゴリズムについてです。2-optや3-optあるいはk-optと言われるアルゴリズムがあるようです。


連続する二点入れ替え:
まず思いつくのが、任意の二点を入れ替えてみてスコアを計算し、もしスコア向上が得られれば採用するというアルゴリズム。このように何か最適化の処理をした後にスコアを評価して、結果がよければそれを採用するというやり方にいくつかあるようです。
最も簡単なのは連続する二点を入れ替える方法。

0 - 1 - 2 - 3 -(4)-(5)- 6 - 7 - 8 - 9 (初期状態)

4と5を入れ替える。

0 - 1 - 2 - 3 -(5)-(4)- 6 - 7 - 8 - 9 (変更後)

3〜6(4、5の前後)までの範囲のスコアを比較計算して向上すれば採用。


二点間反転:
また、遠く離れた二点間を入れ替える場合は、二点だけでなくその間の都市も含めて反転させてつなぎ直すという方法もあります。

0 - 1 - 2 -(3 - 4 - 5 - 6)- 7 - 8 - 9 (初期状態)

3から6を反転する。

0 - 1 - 2 -(6 - 5 - 4 - 3)- 7 - 8 - 9 (変更後)

2〜7(3〜6の前後)までのスコアを比較計算して向上すれば採用。


連続する三点入れ替え:

0 - 1 - 2 - 3 -(4)-(5)-(6)- 7 - 8 - 9 (初期状態)

(4, 5, 6)の三点の組み合わせすべて(6通り)を比較計算する。

0 - 1 - 2 - 3 -(4)-(5)-(6)- 7 - 8 - 9
0 - 1 - 2 - 3 -(4)-(6)-(5)- 7 - 8 - 9
0 - 1 - 2 - 3 -(5)-(4)-(6)- 7 - 8 - 9
0 - 1 - 2 - 3 -(5)-(6)-(4)- 7 - 8 - 9
0 - 1 - 2 - 3 -(6)-(4)-(5)- 7 - 8 - 9
0 - 1 - 2 - 3 -(6)-(5)-(4)- 7 - 8 - 9

3〜7までの範囲を比較計算し、最もスコアの少ない組み合わせを採用。

同様に四点、五点と増やしていけばスコアは向上するけれども、その分組み合わせのパターンも増大するので、ほどほどにしておかないと時間がかかりすぎる(せいぜい五点程度)。


組み合わせ用ライブラリ:
上記のような組み合わせのパターンを導き出すライブラリとしてsympy.utilities.iterables.multiset_permutationsがあります。これを使えば簡単に組み合わせパターンをリストとして取り出せます。


一点を任意の位置へ移動:
また別の方法としてシンプルなのが、一点を異なる場所へ入れ直す方法。

0 - 1 - 2 -(3)- 4 - 5 - 6 - 7 - 8 - 9 (初期状態)

3を1から順に挿入していき比較計算しスコア向上すれば更新する。

0 -(3)- 1 - 2 - 4 - 5 - 6 - 7 - 8 - 9
0 - 1 -(3)- 2 - 4 - 5 - 6 - 7 - 8 - 9
0 - 1 - 2 -(3)- 4 - 5 - 6 - 7 - 8 - 9
0 - 1 - 2 - 4 -(3)- 5 - 6 - 7 - 8 - 9
0 - 1 - 2 - 4 - 5 -(3)- 6 - 7 - 8 - 9
0 - 1 - 2 - 4 - 5 - 6 -(3)- 7 - 8 - 9
0 - 1 - 2 - 4 - 5 - 6 - 7 -(3)- 8 - 9
0 - 1 - 2 - 4 - 5 - 6 - 7 - 8 -(3)- 9
0 - 1 - 2 - 4 - 5 - 6 - 7 - 8 - 9 -(3)

アルゴリズムとしてはシンプルですが、これを開始点0を除いた全ての都市(197768箇所)において順に比較計算させていくと197768*197767回計算させることになり、かなり時間がかかってしまうので、移動したい点に最も近い点を上位五点まで選択しておき、それらのうちでスコア向上が見られるときにだけ採用とするなどの工夫をしました。


素数用ライブラリ:
この他、このコンペ特有のルールとなる素数に関しては、sympy.isprimeをつかうことで、その数が素数かどうかをすぐに判定できます。


最適化の結果:
上記の方法だけでもある程度最適化はできましたが、やはり最初のTSPライブラリによる結果がいいほうが最終的なスコアがよくなってしまいます。自前の欲張り法による初期経路の場合は、一度の最適化でもかなりスコアを向上させることができましたが(もともと改善の余地が多いため)、TSPライブラリによる初期経路の場合は、すでにかなり改善されているためか1%も向上しません。数時間回してやっと1箇所(0.0001%程度)改善するくらいでしょうか。
もっと強力なコンピュータか計算の高速化の工夫も必要そうなので、単なるTSPだけの問題というわけでもなくなってきて奥が深いという感じ。今回はPythonを使いましたが、C++でやったほうがよさそうです。

この他にもいくつか最適化するアルゴリズムを考えてみましたが、計算コストがかかりすぎることから諦めたものもあります(一通り計算させると1ヶ月以上かかってしまうなど)。
順位的には大したことはありませんでしたが、今回もまたTSPという未経験の分野にチャレンジしたことでいろいろと収穫がありました。やはりKaggleに参加するとモチベーションもあがり勉強にもなります。もうコンペ自体は終わってしまいましたが、引き続きTSPの最適化アルゴリズムを考えてみたくなります。

TSP:その2へ続く
関連:Traveling Salesman Problem:巡回セールスマン問題について(まとめ)


Kaggleで勝つデータ分析の技術
門脇 大輔 阪田 隆司 保坂 桂佑 平松 雄司
技術評論社
売り上げランキング: 363

2018年11月20日火曜日

Kaggle Digital Recognizer(MNIST): Keras, fit_generator() + hyperopt

Kaggle Digital Recognizer(MNIST)の続きです。前回から少しだけ内容を変えてみたらベストスコアがでました。
改良点は以下です。

fit_generator():
前回は、通常の訓練model.fit()を使った後にData Augmentationとしてmodel.fit_generator()を追加して二段階で訓練しましたが、今回は最初からfit_generator()だけで訓練してみることにしました。

BatchNormalization:
CNNに関しては前回よりも層を少なくして、conv2dの後に必ずBatchNormalization()を入れ、プーリング層(学習なし)を使わずにstrides=2のconv2d()(学習あり)で1/2にダウンサンプリングすることにしました。

Hyperopt:
Hyperoptに関しては前回同様Dropout率だけを最適化しています(合計3箇所)。探索回数はとりあえず10回。

スコア:
結果はこれまでのベストスコアである0.99771(Top 5%)まで向上しました。
この辺りまで来るとスコアを0.001上げるのはかなり至難の技で、正直0.997以上になるとは期待していませんでした。しかし予想以上に満足できる結果が得られたので、Digital Decognizer(MNIST)に関してはひと段落ついたという感じです。

ただし、調べれば調べるほど興味深い項目が登場してきて、今後試してみたいのは:
・他のMNISTデータセットで今回のモデルの精度を確かめてみる(KaggleのMNISTデータセットにオーバーフィッティングしていないかどうかの検証)。
・今回はHyperoptによってDropout率を自動的に決定させましたが、Dropoutを一般化したDropconnectというのもあるらしく、それを使うとどうなるか(Keras Dropconnect Implementation)?

Kaggleで勝つデータ分析の技術
門脇 大輔 阪田 隆司 保坂 桂佑 平松 雄司
技術評論社
売り上げランキング: 363


追記:
その後、既存のkeras.datasets.mnistのデータセット(60000+10000)で検証してみると0.997以上の正解率となりました。おそらくKaggleのMNISTデータも多数含まれているので似たような結果となったのだと思います(しかし偶然KaggleのMNISTデータだけにオーバーフィットしすぎているというわけでもなさそう)。
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.

2018年11月16日金曜日

Kaggle Digital Recognizer(MNIST): Hyperopt + Data Augmentation

引き続きKaggle Digital Recognaizer(MNIST)のスコア向上のため、今回はHyperoptData Augmentationを組み合わせてみました。
結果として、これまで0.995前後(Top 18%)のスコアがでていましたが、今回の方法で0.99671(Top 9%)まで向上しました。それでも28000個あるデータのうち92個が間違っているということになります。


今回の方法:

・畳み込み層を増やしてもう少し特徴量検出できるようにする
・あまり自動調節させるハイパーパラメータは増やさない
・バッチサイズやデータ分割などは一般的な値にしておく
・Dropout率でモデル全体の精度を調整

要は、Hyperoptによるハイパーパラメータ最適化はDropout率(合計5個)だけに絞り、その他は固定。
探索回数は20回(GTX1060で約2時間)。

前回までと異なるのは:
・ダブルの畳み込み層をもう一式追加
・Dense層出力ユニット数の増加
・最後にData Augmentationでの訓練を追加
ということになります。

Data Augmantation(訓練データの変形加工:水増し)するためにKerasのImageDataGeneratorを使用しました。
ImageDataGeneratorを使うには元データのshapeを(-1, 28, 28, 1)にしておく必要があるようです。これまではCNNモデル入力層でkeras.layers.Reshape()を使って(784, )から(-1, 28, 28, 1)に変換していましたが、ImageDataGeneratorの入力次元数とモデルの入力次元数が異なるためエラーがでてしまい、モデルに入力する前に(-1, 28, 28, 1)へ変換することにしました。

流れとしては:
・訓練画像を元にHyperoptで最適化
・最適化されたモデルをData Augmentationで追加訓練
という二段階の訓練です。
Data Augmentationの訓練は結構すぐに収束してしまいましたが、その訓練の差なのかほんのわずか向上しました。


まとめ:
個人的には、これまでスコア0.995が壁になっていて、手動でいろいろ試してみたけれどもなかなか超えられませんでした。今回のスコアは期待していた以上に良かったので、MNISTに関してはもうこの辺で充分かと思いますが、あと試してみたいのは以下。
・最初からImageDataGeneratorで訓練
・交差検証(KFold

基本的なMNIST分類問題ですが、こうやってスコア向上を目標に試してみると、いろんなテクニックが見つかりかなり勉強になります。基本的なCNNアルゴリズムだけでなく、その他の方法も組み合わせることでわずかながらでも向上するということが分かったのもよかったです。

関連:
Kaggle Digital Decognizer(MNIST): Keras, fit_generator() + hyperopt


Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
直感 Deep Learning ―Python×Kerasでアイデアを形にするレシピ
Posted with Amakuri at 2018.12.21
Antonio Gulli, Sujit Pal
オライリージャパン
販売価格 ¥3,672

2018年11月14日水曜日

GPyOpt: Digital Recognizer(MNIST) CNN Keras ハイパーパラメータ最適化

引き続きハイパーパラメータ最適化として、今回はGPyOptを使ってみました。これまでHyperasHyperoptを試して見ましたが、ベイズ最適化でも採用しているアルゴリズムが微妙に違うようなので試してみたという感じです。
個人的にはHyperoptが一番使いやすく感じましたが、GPyOptは以前scikit-learnで試したベイス最適化に近いアルゴリズムだったのでもう少し理解を深めてみようかと。
まだ手探り段階なので、使い方に関しては後から追記するかもしれません。


使い方:

ハイパーパラメータの設定:
まずはMNISTモデルにおけるハイパーパラメータの設定からです。今回はやや少なめで。

最適化するハイパーパラメータ:
・各層のドロップアウト率:連続値
・Dense層出力ユニット数:離散値
・validation_splitの比率:連続値

GPyOptではハイパーパラメータを以下のようなフォーマットで書きます。
params = [
    {'name': 'Dropout_0',        'type': 'continuous',  'domain': (0.0, 0.5)},
    {'name': 'Dropout_1',        'type': 'continuous',  'domain': (0.0, 0.5)},
    {'name': 'Dropout_2',        'type': 'continuous',  'domain': (0.0, 0.5)},
    {'name': 'Dropout_3',        'type': 'continuous',  'domain': (0.0, 0.5)},
    {'name': 'Dense_0',          'type': 'discrete',    'domain': (128, 256, 512)},
    {'name': 'Dense_1',          'type': 'discrete',    'domain': (64,128, 256)},
    {'name': 'validation_split', 'type': 'continuous',  'domain': (0.1, 0.3)}
]

リスト化されたディクショナリーで(ここを参考に)、

・'name' : パラメータ名
・'type' : 'continuout'(連続値)、'discrete'(離散値)、'categorical'(分類値)
・'domain' : 適用範囲または選択肢を()で括る

となるようです。


CNNモデルの構築:
次にモデルを構築します。前回同様MNIST分類用のCNNを使います。このモデルからはベイズ最適化するための評価値となるlossかaccが求められればいいのですが、

・loss
・acc
・model
・history

の4種類を戻り値にしておきました。
model.fit()させてEarlyStoppingで打ち切りになった最後のval_lossとval_accの値を参照しています。
    loss = hist.history['val_loss'][-1]
    acc = hist.history['val_acc'][-1]
modelやhistoryは不要ですが、後から参照するかもしれないので一応入れておきました(使うかどうかは分からない)。
return loss, acc, model, hist

上記パイパーパラメータに対応する変数部分には、x[:, 0]などと引数にインデックス番号をつけるようですが、どれが何番目かはわかりにくいのでハイパーパラメータの'name'から参照できる関数をつくってみました。
model.add(Dropout(Param('Dropout_0'), seed=seed))
このように書き込めばx[:, 0]へ自動変換してくれます。Hyperoptなどでもディクショナリーのキーを使っていたので、このほうが個人的には使いやすいかと(リスト内容を変えた場合にインデックス番号だと、他の番号も変わってしまうのが面倒なので)。
注意点として、最初に書いたハイパーパラメータはリストであるのに対して、この変数は2次元のndarrayに変換されてから代入されるようです。この変換関数は以下(cnn_model関数内)。
    def Param(p_name):
        p_index = [p['name'] for p in params].index(p_name)
        p_type = params[p_index]['type']
        
        if type(x) is np.ndarray:
            if p_type == 'continuous':
                return float(x[:, p_index])
            else:
                return int(x[:, p_index])
        else: # list
            if p_type == 'continuous':
                return float(params[p_index]['domain'])
            else:
                return int(params[p_index]['domain'])
後で最適化されたハイパーパラメータリストを直接渡せるようにしてあります。引数がndarrayならx[:,0]のような2次元ndarray、listならlist内のスカラー値へ変換後代入。また今回の場合、離散値はすべて整数だったのでintかfloatかも振り分けています。


フィッティング関数:
上記CNNモデルを以後のベイズ最適化関数GPyOpt.methods.BayesianOptimization()に直接渡してもいいのですが、CNNモデルからは4種類の値を出力することにしたので、このf(x)関数を間にはさんで必要な評価値だけを渡せるようにしました。今回はaccを評価値として渡すことにし、最小化するためにマイナス反転して-accにしています。
前述のように引数のxは二次元のnumpy.ndarrayになるようです。今回は7種類のハイパーパラメータがあるので、x.shapeは(1,7)になります。最初に設定したハイパーパラメータはリストでありndarrayではないので、この辺をいじる場合は変換するなどの工夫が必要です(このサンプルを参照)。
実際は、
def f(x):
    x = np.atleast_2d(x)
    fs = np.zeros((x.shape[0],1))
    for i in range(x.shape[0]):
        loss, acc, model, hist = cnn_model(x)
        fs[i] += np.log(acc)*(-1)
    return fs
このように書いたほうがいいのかもしれませんが、戻り値は1次元のndarrayだったので、今回は省略して以下のようにしました。対数変換したほうがいいのかもしれませんが効果の違いは検証していません。
def f(x):
    loss, acc, model, hist = cnn_model(x)
    return -acc

ベイズ最適化関数:
GPyOpt.methods.BayesianOptimization()に先程のf(x)関数とハイパーパラメータリストparamsを渡し、その他初期探索値や獲得関数などを決めます。獲得関数はデフォルトではEIになっていますが'EI_MCMC'を選んでみました。'EI_MCMC'を選択する場合は、model_typeで'GP_MCMC'を選んでおかなければいけないようです。
initial_design_numdataは20に設定しましたが、これはどのくらいがいいのかは不明(デフォルト:5)。探索する前のランダムな開始点の数なのかもしれませんが、今回の7次元に対してどのくらいが適当なのか?探索点は徐々に追加されながらフィッティングしていくと思うのでデフォルトの5でもいいのかもしれません。入れた回数だけループするようです(20回で約1時間)。
こまかな設定がいくつかありますが、まだ使いながら試している段階です。

次に、run_optimization(max_iter=50)で最適化が始まります。イテレーションを50回に設定しました。7種類のハイパーパラメータに対してどのくらいが適当なのかはまだ不明(ハイパーハイパーパラメータ)。50回で約4時間かかりました。
ループが終了すれば最適なハイパーパラメータが見つかったことになります。設定した回数より早く終わることもあります。


最適化されたハイパーパラメータの取得:
以下で結果を取得することができます。
x_best = opt.x_opt
print([i for i in x_best])

y_best = opt.fx_opt
print(y_best)
そうすると、
[0.1732254530746627, 0.39555160207057505, 0.14877909656106353, 0.07323704794308367, 128.0, 128.0, 0.1471216716379693]
-0.9945388349514563
と値が出てきて、最初のリストが最適化された各ハイパーパラメータ。
下の値はそのときのロス値。今回はaccをマイナス反転してあるのでaccの値と同じ。精度0.994以上でているのでまあまあの結果です。


最適化されたハイパーパラメータをモデルに適用:
上記結果と同時にベストモデルやベストウェイトを直接取り出したいのですが、そのような方法がGPyOptにはないようなので、最適化されたハイパーパラメータをCNNモデルに入れ直して再度訓練させてみました。
一応、上記ハイパーパラメータリストを元々のディクショナリー型のリストへ移し替えてからCNNモデルに渡しています。CNNモデルの引数がlistの場合はスカラー値を各変数に代入するような関数にしています。
CNNモデルはEarlyStopping機能をつけているので15ループで収束してくれました(4分25秒)。
このモデルを利用して提出用データを予測します。


まとめと結果(スコア):
最終的にスコアは0.99457でした。まあまあいい結果です(それでも手動調整のベストスコアである0.99528には達していない)。約6時間でこの結果ですが、もっと回せば向上するかはわからないです。これ以上のスコアを出すには、data augmentationでデータを水増しするなど必要かもしれません。
GpyOptはHyperoptに比べるとやや使いにくいという印象でした(サンプルも少ない)。しかしやりたいことに応じて使いやすく改造すればいいのかもしれません。もともとのアルゴリズム自体は優れていると思うので、いくつかを同時に試して結果的にいい方を選ぶ感じでしょうか。時間的にもHyperoptのほうが速いかもしれませんが、どのライブラリであっても数時間はかかるので時間よりも精度がでるほうがいいと思います(仕事で使っているわけではないので)。
このほか気になるライブラリとして、SkoptKoptPyBOSpearMintなどありますが、とりあえずはもう十分かと。

これまでは機械学習理論やアルゴリズムの種類を覚えていくことが面白かったのですが、Kaggleをきっかけにスコア(精度)を少しでもあげようとすることにも興味を持てたのはよかったです。実際使ってみて、その結果から次にどうすればいいのかという具体的な疑問が次のモチベーションになるので、より理解も深まりつつ面白くなっていく感じです。

追記:
その後、4つのDropout率だけをハイパーパラメータとして最適化した結果スコア:0.99557まで向上(これまでのベストスコアは0.99524)。
その他のハイパーパラメータは以下のように固定。
validation data:test_size=0.15
Dense_0 output units: 256
Dense_1 output units: 128
batch_size=32

そして最適化においては以下の探索回数に設定。
initial_design_numdata=30(2h 29mins)
max_iter=100(stop at 52: 7h 47mins)
max_iterは最大100回に設定しましたが途中52回で収束し停止しました。
合計で10時間30分(GTX1060で)。

関連:
Kaggle Digital Recognizer(MNIST): Hyperopt + Data Augmentation
Kaggle Digital Decognizer(MNIST): Keras, fit_generator() + hyperopt


Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.

機械学習スタートアップシリーズ ベイズ推論による機械学習入門 (KS情報科学専門書)
Posted with Amakuri at 2018.12.21
須山 敦志
講談社
販売価格 ¥3,024(2018年12月21日20時40分時点の価格)

2018年10月24日水曜日

Kaggle:その2(Titanic、Mnistなど)

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

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

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

from keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=3, min_lr=0.000001,verbose=1)
checkpointer = ModelCheckpoint(filepath='checkpoint.hdf5', verbose=1, save_best_only=True)
early_stopping = EarlyStopping(patience=10, verbose=1)
history = model.fit(x_train, y_train,
epochs=300,
batch_size=32,
verbose=1,
validation_split=0.1,
callbacks=[reduce_lr, early_stopping, checkpointer])
model.load_weights('checkpoint.hdf5')
pred = model.predict(x_test)
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)。
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.

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

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

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

Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
表示されない場合はこちら

サンプルなどでよくある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で勝つデータ分析の技術
門脇 大輔 阪田 隆司 保坂 桂佑 平松 雄司
技術評論社
売り上げランキング: 363

2018年9月29日土曜日

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で勝つデータ分析の技術
門脇 大輔 阪田 隆司 保坂 桂佑 平松 雄司
技術評論社
売り上げランキング: 363


事前準備:
あとで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)。まだベースライン前後なので、もう少し改良が必要です。

Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.

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

人気の投稿