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

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



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


2019年1月17日木曜日

TSP(巡回セールスマン問題):その2

前回のTSP(巡回セールスマン問題)の続きです。前回のKaggleコンペでは都市が197769もあり、計算するにもかなり時間がかかったので、都市数を減らしたサンプルで最適化アルゴリズムについて確かめてみました。

総当たりで計算すると都市数が10を超えるあたりからきつくなっていくので、真のスコアと比較検証するには少なめの都市数にする必要があります。


ライブラリ:
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
from numba import jit, prange
from itertools import permutations
from tqdm import tqdm_notebook as tqdm
np.random.seed(seed=42)
まずは必要そうなライブラリ。numbaでどれだけ高速になるかはわかりませんが一応入れておきます。組み合わせのパターンを求めるにはitertools.permutationsを用いました。


都市数や座標の設定:
num = 10                                      # the number of cities
path = np.concatenate([np.arange(num), [0]])  # path starts from 0 and ends with 0
X = np.random.random(num)                     # X-coordinates of cities
Y = np.random.random(num)                     # Y-coordinates of cities
XY = X + Y * 1j                               # complex numbers of X and Y
都市は合計10箇所、0〜9までの番号を割り当てておきます。最後に0に戻るので経路としては
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
の11要素になります。
それぞれにランダムでXとYの座標を与え、距離を求めるための複素数XYも用意しておきます。


スコア関数:
def score(path, a, b):
    c = XY[path[a: b+1]]
    sc = np.sum(np.abs(np.diff(c)))
    return sc
都市aからbに至るスコア(道のり)を求めるための関数を用意しておきます。複素数XYの差分をnp.abs()を使って求めます。


経路のプロット:
def plot_path(path):
    PX = [X[i] for i in path]
    PY = [Y[i] for i in path]
    plt.figure(figsize=(5,5))
    plt.axis('equal')
    plt.plot(PX, PY)
    plt.scatter(PX, PY)
    plt.scatter(PX[0], PY[0], s=80, c='r', marker='o')
    for i in range(num):
        plt.text(PX[i], PY[i]+0.03, s=i, fontsize=12, color='gray')
    print('Total Score: ', score(path, 0, len(path)))
開始点を赤点表示。巡回順のナンバリングもしておきます。
初期経路はランダムなので表示させるとこのような感じになります。
4と5がほぼ重なっていて見にくいですがこのままで。


真のスコアを求める:
総当たりで計算する場合、12都市以上になると何時間もかかるため、都市数を指定できるような関数にしました。10都市の場合は巡回すると11都市になり、開始点と到着点の二点を除いた9都市の組み合わせすべてについて計算します。9都市なら3分、10都市なら30分以上かかります。
def opt_n(path, n):
    for i in tqdm(range(1, len(path)-n)):
        perm = np.array(path[i:i+n])
        combs = np.array(list(permutations(perm)))
        sc1 = score(path, i-1, i+n+1)
        sc3 = np.inf
        for comb in combs:
            copy = np.concatenate([path[:i], comb, path[i+n:]])
            sc2 = score(copy, i-1, i+n+1)
            if sc1 > sc2:
                if sc3 > sc2:
                    sc3 = sc2
                    path = copy.copy()
                    print('Improved to: ', score(path, 0, num))
    return path


二方向の欲張り法:
ランダムな初期経路に対して最適化していってもいいかもしれませんが、欲張り法でもう少しまともな経路をつくっておきます。
スタート地点から最も近い都市をつなぎ続けていきます。スタート地点から二方向に都市をつなげていき、その二つの経路を中点でつなぎます。
@jit('i8[:](i8[:], i8, i8)')
def closest_num(path, num, index):
    copy = path.copy()
    d = np.array([np.abs(XY[index] - XY[i]) for i in copy])
    arg = d.argsort()
    closest_index = np.array([copy[i] for i in arg])[:num]
    return closest_index

@jit('i8[:](i8[:])', parallel=True)
def find_path(path):
    copy = path[1:-1].copy()
    half = len(copy)//2 + 1
    path1 = np.array([0])
    path2 = np.array([0])
    for i in tqdm(prange(half)):
        if len(copy) > 0:
            c1 = closest_num(copy, 1, path1[-1])
            path1 = np.append(path1, c1)
            copy = np.delete(copy, np.where(copy==c1))
        if len(copy) > 1:  
            c2 = closest_num(copy, 1, path2[-1])
            path2 = np.append(path2, c2)
            copy = np.delete(copy, np.where(copy==c2))
        
    print('Path_1:', path1, '\nPath_2:', path2[::-1])
    return np.concatenate([path1, path2[::-1]])
どのくらい効果的かはわかりませんが、一応使ってみます。

ランダムよりはまともな経路になりますが、まだまだ改良の余地があります。


二点間反転:
欲張り法で得た経路を最適化するアルゴリズムです。任意の二点間を選び、その区間を反転して繋ぎ直します。
@jit('i4[:](i4[:], i4)')
def opt_n_flip(path, n):
    for i in range(0, len(path)-n-1):
        n1 = i
        n2 = n1 + n
        sc1 = score(path, n1-1, n2+1)
        rev = path[n1: n2+1][::-1]
        copy = np.concatenate([path[:n1], rev, path[n2+1:]])
        sc2 = score(copy, n1-1, n2+1)
        if sc1 > sc2:
            path = copy.copy()
            print('Improved to: ', score(path, 0, len(path)-1))
    return path

@jit(parallel=True)
def opt_flip_loop(path, n, num):
    for i in tqdm(prange(n, n+num)): 
        path = opt_n_flip(path, i)
    return path
まずは隣り合わせの二都市、次は一つ離れた二都市、そして二つ離れた二都市という具合にN個分離れた二都市までを評価して、向上が見られれば随時更新していきます。
最適化の結果、都市数が少ないためか、ほぼ正解にたどり着いたようです。


一点移動挿入:
or-optというアルゴリズムに近い方法です。経路から一つだけずれている都市を最適な場所に移動してくれます。
def longest(path):
    sc_arr = - np.array([np.sum(np.abs(np.diff(np.array(XY[path[i-1: i+1]])))) for i in tqdm(range(1, len(path)-1))])
    arg = sc_arr.argsort()    
    return arg

def closest_n(path, n, index):
    copy = path[1:-1].copy()
    if path[index] in copy:
        copy = np.delete(copy, np.where(copy==path[index]))
    d = np.array([np.abs(XY[index] - XY[i]) for i in copy])
    arg = d.argsort()
    closest_index = np.array([copy[i] for i in arg])[:n]
    return closest_index

@jit('i8[:](i8[:])', parallel=True)
def or_opt(path):
    lon = longest(path)
    print('Initial Score: ', score(path, 0, num))
    for i in tqdm(lon):
        sc3 = np.inf
        c5 = closest_n(path, 10, path[i])
        for c in c5:
            j = np.where(path==c)[0][0]
            copy = np.delete(path, i)
            copy = np.insert(copy, j, path[i])
            if i >= j:
                sc1 = score(path, j-1, i+1)
                sc2 = score(copy, j-1, i+1)
            else:
                sc1 = score(path, i-1, j+1)
                sc2 = score(copy, i-1, j+1)
            if sc1 > sc2:
                if sc3 > sc2:
                    sc3 = sc2
                    path = copy.copy()
                    print('Improved to: ', score(path, 0, num))
    return path
まず二点間距離の降順リストをつくり、その都市の最も近くにある都市(上位5都市)の次の位置へ移動しスコアが向上すれば更新します。
最適化しても前回と結果は同じです。おそらくこれが正解の経路。


正解の経路:
最後に真のスコアを求めるためにつかったopt_nで再度最適化させます(都市数が多い場合はせいぜい10都市までの組み合わせによる最適化)。今回の場合は都市数が少ないのでopt_nに9を代入すれば正解が得られます(以下)。組み合わせは9!=362880通り(約3分)。


全体の流れ:
・ランダムに経路を生成
・欲張り法で経路を生成(find_path)
・二点間反転(opt_n_flip)
・一点移動挿入(or_opt)
・組み合わせ最適化(opt_n)

都市数が少ない場合は二点間反転だけでも真の経路になる場合がありました。ひとつのアルゴリズムを一度実行しただけでは最適化不十分なので、スコアが向上しなくなるまで複数回繰り返します。
都市数を20、30と増やしていくと、真の経路を求めるには時間がかかりすぎるので比較評価することができません。よって最適化によってスコアを徐々に向上していくしかありません。
複数のアルゴリズムをスコア向上しなくなるまで実行することで、ぱっと見は最適解になっているように見えますが、ランダムで生成した経路を最適化した場合と欲張り法のあとで最適化した場合とで結果が異なるので初期経路次第という感じです。今回は欲張り法でしか初期経路を生成していないので、もう少し他の方法も試してみる必要がありそうです。焼きなまし法というのもあるらしく、最初から最短都市や最少スコアを優先するアルゴリズムにするのではなく、許容値を設定して多少スコアオーバーしても採用するなどしたほうがいいかもしれません(この部分に関しては次回)。


以下は都市数100の場合(正解の経路とは限らない):

初期ランダム経路
Total Score:  52.8760351727298

欲張り法(二方向)による経路
Total Score:  9.979255125288242
まだ交差している経路があります。

二点間反転による最適化
Total Score:  8.764946875917067
交差していた経路がなくなって、ほぼ最適解。

一点移動挿入による最適化
Total Score:  8.463720661190624
細部の修正と最適化(わずかながらスコアは向上しています)。
ここまでは数秒で終了。

組み合わせ数8による最適化(8-opt)
Total Score:  8.435705379605803
さらなる最適化(右下の部分が改善)。
経路の組み合わせが8!=40320通りあるので、この工程だけ時間がかかります(1分43秒)。
よく見ると、赤点近くの98と99を83と82につなげたほうがスコアが向上しそうです。まだ赤点付近が上手く最適化できないので改善の余地あり。

対策:
局所的には最適化されスコアは向上しましたが、初期経路によってその後の最適化が左右されてしまうという弱点があります。初期経路生成の工夫をするか、後からでも大規模な経路変更が可能になる方法を探さないといけないかもしれません。最初に多少スコアオーバーしても許容する大規模な経路変換を行ったのちに局所的な最適化を行って、結果的にスコアが向上するような二段階の最適化をするといいのかもしれません。

続き:convex hull:凸包/ギフト包装法/Graham scanアルゴリズム
関連:Traveling Salesman Problem:巡回セールスマン問題について(まとめ)





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データだけにオーバーフィットしすぎているというわけでもなさそう)。

人気の投稿