深層強化学習入門: TensorFlow で初めてのゲーム AI を構築する

[[210667]]

昨年、DeepMindのAlphaGoは世界囲碁チャンピオンのイ・セドルを4対1で破った。強化学習が世界の舞台に登場した様子を、2億人を超える視聴者が視聴しました。数年前、DeepMind は Atari のゲームをプレイできるロボットを開発して話題を呼んだ。同社はすぐにGoogleに買収された。

多くの研究者は、強化学習が汎用人工知能を生み出すための最善の方法であると考えています。これは多くの未解決の課題と大きな可能性を秘めた刺激的な分野です。

強化学習は最初は非常に難しいように思えるかもしれませんが、実際に始めるのは難しくありません。この記事では、キャッチゲームをプレイできるシンプルな Keras ベースのボットを作成します。

キャッチゲーム

[[210668]]

オリジナルのキャッチゲームインターフェース

キャッチは、子供の頃に遊んだことがあるかもしれない非常にシンプルなアーケードゲームです。ゲームのルールは次のとおりです。果物が画面の上から落ちてくるので、プレイヤーはバスケットでそれをキャッチする必要があります。キャッチした果物ごとに、プレイヤーは 1 ポイントを獲得します。逃した果物ごとに、プレイヤーは 1 ポイントを失います。ここでの目標は、コンピューターが自力でキャッチゲームをプレイできるようにすることです。ただし、このような美しいゲームインターフェースは使用しません。代わりに、タスクを簡素化するために、ゲームの簡略化されたバージョンを使用します。

簡素化されたキャッチゲームインターフェース

キャッチゲームをプレイする場合、プレイヤーは 3 つの可能なアクションの中から選択します。プレイヤーはバスケットを左、右に動かしたり、静止させたりすることができます。この決定はゲームの現在の状態によって異なります。つまり、果物がどこに落ちるか、バスケットの位置によって異なります。私たちの目標は、ゲーム画面の内容に基づいて、最高スコアをもたらすアクションを選択するモデルを作成することです。

このタスクは単純な分類問題として考えることができます。ゲームの専門家にゲームを複数回プレイしてもらい、その行動を記録します。その後、ゲームの専門家がプレイする方法と同様に、「正しい」アクションを選択することでモデルをトレーニングできます。

しかし、これは実際には人間が学習する方法ではありません。人間は、何の指導も受けずにキャッチボールのようなゲームを自分で学ぶことができます。これはとても便利です。「キャッチ」のような簡単なゲームを習得したいたびに、そのゲームを何千回もプレイする専門家チームを雇わなければならないとしたらどうでしょう。これは必然的に非常に高価で時間がかかります。

強化学習では、モデルはラベル付けされたデータに基づいてトレーニングされるのではなく、過去の経験を通じてトレーニングされます。

深層強化学習

強化学習は行動心理学にヒントを得ています。モデルに「正しい」動作を与える代わりに、報酬とペナルティを与えます。モデルは、環境の現在の状態 (コンピューターゲーム画面など) に関する情報を取得します。すると、ゲームコントローラーと同じようにアクションが出力されます。環境はこのアクションに応答し、次の状態と報酬または罰の行動を提供します。

[[210670]]

そこからモデルは学習し、報酬を最大化するアクションを探します。

実際には、これを行う方法はたくさんあります。次に、Q学習について見てみましょう。 Q-Learning は、コンピューターに Atari ゲームをプレイするようトレーニングするために使用されたときに大きな話題を呼びました。今日でも、Q 学習は依然として非常に重要な概念です。最新の強化学習アルゴリズムのほとんどは、Q 学習の改良版です。

Q学習を理解する

Q 学習を理解する良い方法は、キャッチゲームとチェスゲームを比較することです。

どちらのゲームでも、状態 S が与えられます。チェスでは、これは盤上の駒の位置を表します。キャッチゲームでは、これは果物とバスケットの位置を表します。

次に、プレイヤーは A と呼ばれるアクションを実行します。チェスでは、プレイヤーは駒を動かします。キャッチゲームでは、バスケットを左、右に動かすか、現在の位置に維持することを意味します。これに基づいて、報酬 R と新しい状態 S' が得られます。

キャッチゲームとチェスの共通点の 1 つは、アクションの直後に報酬が現れないという点です。

キャッチゲームでは、果物がバスケットに落ちるか、床に落ちた場合にのみ報酬が得られます。チェスでは、ゲーム全体の勝敗が決まった後にのみ報酬が与えられます。これは報酬がまばらに分配されることを意味します。ほとんどの場合、R はゼロのままです。

生成される報酬は必ずしも前のアクションの結果ではありません。おそらく、ずっと以前にとられた何らかの行動が勝利の鍵だったのでしょう。最終的な報酬の原因となるアクションを特定することは、多くの場合、クレジット割り当て問題と呼ばれます。

報酬は遅れて得られる性質があるため、優れたチェスプレイヤーは、最もすぐに目に見える報酬だけに基づいて動きを選択することはありません。代わりに、彼らは予想される将来の報酬を考慮し、それに基づいて選択を行います。たとえば、次の動きで相手の駒の 1 つを除去できるかどうかだけを考慮するのではなく、また、長期的に見て有益な行動も検討します。

Q 学習では、最も高い将来の報酬が期待されるものに基づいてアクションを選択します。この計算には Q 関数を使用します。この数学関数は、ゲームの現在の状態と指定されたアクションという 2 つの変数を取ります。したがって、これをQ(状態、アクション)として記録できます。状態 S では、各可能なアクション A の報酬を推定します。アクション A を実行して次の状態 S' に入った後、すべてが完璧であると想定します。

与えられた状態SとアクションAに対して、期待される将来の報酬Q(S,A)は、即時の報酬Rとその後の期待される将来の報酬Q(S',A')の合計として計算されます。次のアクションA'が最適であると仮定します。

将来の不確実性のため、Q(S', A')に係数γを掛けて割り引きます。

Q(S,A) = R + γ * 最大Q(S',A')

チェスの名人は将来の報酬を頭の中で予測するのが得意です。言い換えれば、Q関数Q(S,A)は非常に正確です。ほとんどのチェスのトレーニングは、より優れた Q 関数の開発を中心に行われます。プレイヤーはチェスのマニュアルを使用して、特定の動きがどのように発生するか、また特定の動きが勝利につながる可能性がどの程度あるかを学びます。しかし、機械はどのようにして Q 関数の品質を評価するのでしょうか?ここでニューラルネットワークが役立ちます。

最終申告

ゲームをプレイするとき、次のような部分を含む多くの「体験」があります。

初期状態、S
取られた措置、A
受け取った報酬、R
次の状態、S'

これらの経験が私たちのトレーニングデータとなります。 Q(S,A)を推定する問題を回帰問題として定義することができます。この問題を解決するには、ニューラルネットワークを使用できます。 S と A からなる入力ベクトルが与えられた場合、ニューラルネットワークは Q(S, A) の値がターゲット R + γ * max Q(S', A') に等しいと予測できる必要があります。

異なる状態Sと異なるアクションAに対するQ(S, A)を非常に正確に予測できれば、Q関数を非常に正確に近似することができます。 Q(S, A)と同じニューラルネットワークを介してQ(S', A')を推定することに注意してください。

トレーニングプロセス

一連の経験 <S、A、R、S'> が与えられた場合、トレーニングプロセスは次のようになります。

それぞれの可能なアクション A' (左、右、アクションなし) について、ニューラルネットワークを使用して、予想される将来の報酬 Q(S'、A') を予測します。
3つの期待される将来の報酬の最大値をmax Q(S', A')として選択します。
ニューラルネットワークの目標値であるr + γ * max Q(S', A')を計算します。
損失関数を使用してニューラルネットワークをトレーニングします。損失関数は、予測値と目標値の間の距離を計算します。ここでは、損失関数として0.5 * (predicted_Q(S,A) — target)²を使用します。

ゲーム中、すべての体験はリプレイメモリに保存されます。これは、<S、A、R、S'> ペアを格納する単純なキャッシュのようなものです。これらのエクスペリエンスリプレイクラスは、トレーニングデータを準備するためにも使用できます。次のコードを見てみましょう。

クラスExperienceReplay(オブジェクト):
 「」 「 」
    ゲームプレイ中、すべての経験 < s、a、r、s' > はリプレイ メモリに保存されます。
トレーニングでは、ランダムに抽出された経験のバッチを使用して、トレーニングの入力とターゲットが生成されます。
 「」 「 」
    def __init__(self、max_memory=100、discount=.9):
 「」 「 」
        設定
        max_memory:保存したいエクスペリエンスの最大数
        記憶：経験のリスト
        割引:将来の経験に対する割引率
         
メモリには、ゲームがその状態で終了したかどうかの情報がネストされた配列に別々に保存されます。
        [...
        [経験、ゲームオーバー]
        [経験、ゲームオーバー]
        ...]
 「」 「 」
        自己.max_memory = 最大メモリ
        自己メモリ = リスト()
        self.discount = 割引
 
    def remember(self, states, game_over):
        #状態をメモリに保存する
        self.memory.append([状態、ゲームオーバー])
        #無限のメモリを保存したくないので、多すぎる場合は、最も古いものを削除します
        len(self.memory) > self.max_memoryの場合:
            del self.memory[0] 
 
    def get_batch(self, モデル, batch_size=10): 
         
        #私たちにはいくつの経験があるでしょうか?
        len_memory = len(自己メモリ) 
         
        #ゲーム内で実行可能なアクションの数を計算する
        num_actions = モデル.output_shape[-1] 
         
        #ゲームフィールドの寸法
        env_dim = 自己.メモリ[0][0][0].形状[1] 
         
        #私たちは 観測された状態からの入力を含む入力ベクトルとターゲット ベクトルを返します...
        入力 = np.zeros(( min (len_memory, batch_size), env_dim)) 
         
        #...そしてターゲットr + gamma * max Q(s',a')
        #ターゲットは行列であり、可能なフィールドは のみ 取られた行動に対してだけでなく
        # 他の可能なアクションについては、アクションは予測と同じ値を取りません。  影響を与えない
        ターゲット = np.zeros((inputs.shape[0], num_actions)) 
         
        #学習する州をランダムに選びます
i , idx in enumerate(np.random.randint(0, len_memory,
サイズ=inputs.shape[0])):
 「」 「 」
            ここで、メモリから1つの遷移<s, a, r, s'>をロードします。
            state_t: 初期状態s
            action_t:実行されたアクション
            reward_t: 獲得した報酬 r
            state_tp1: s'に続く状態
「」 「 」
            state_t、action_t、reward_t、state_tp1 = self.memory[idx][0] 
             
            #ゲームがこの状態で終了したかどうかも知る必要があります
            ゲームオーバー = 自己メモリ[idx][1] 
 
            #入力に状態sを追加する
            入力[i:i+1] = state_t 
             
            #まず目標値を入力します モデルの予測と一致します。
            # トレーニングによる影響を受けません（トレーニング損失は0なので）
            ターゲット[i] = model.predict(state_t)[0] 
             
 「」 「 」
            ゲームが終了した場合、期待報酬Q(s,a)は最終報酬rになるはずです。
            それ以外の場合、目標値はr + gamma * max Q(s',a')です。
 「」 「 」
            # ここで Q_saはmax_a 'Q(s' , a')です
            Q_sa = np.max (モデル予測(state_tp1)[0]) 
             
            #ゲームが終了した場合、報酬は最終報酬となります
            if game_over: # game_overの場合 真実 
                ターゲット[i, action_t] = reward_t
それ以外：
                # r + ガンマ *最大Q(s',a')
                ターゲット[i, action_t] = reward_t + self.discount * Q_sa
入力、ターゲットを返す

モデルの定義

それでは、Q 学習を使用してキャッチゲームを学習するためのモデルを定義しましょう。 Tensorflow のフロントエンドとして Keras を使用します。私たちのベースラインモデルは、シンプルな 3 層の高密度ネットワークです。このモデルは、キャッチゲームのシンプルなバージョンでうまく機能します。完全な実装は GitHub でご覧いただけます。

より複雑なモデルを試して、より良いパフォーマンスを実現できるかどうかを確認することもできます。

 num_actions = 3 # [左に移動、そのまま、右に移動]
 hidden_size = 100 #サイズ 隠れた層の
grid_size = 10 #サイズ 競技場の
 
 def baseline_model(グリッドサイズ、アクション数、隠しサイズ):
    #kerasでモデルをセットアップする
    モデル = シーケンシャル()
    モデルを追加します(Dense(hidden_size, input_shape=(grid_size**2,), activation= 'relu' ))
    モデルを追加します(Dense(hidden_size, activation= 'relu' ))
    model.add(密(num_actions))
    モデルをコンパイルします(sgd(lr=.1)、 "mse" )
リターンモデル

探検する

Q 学習の最後の要素は探索です。日々の生活は、日常の行動よりも良いことがあるかどうかを知るために、時には奇妙なことやランダムなことをしなければならないということを教えてくれます。

Q学習でも同様です。常に最善の選択をするということは、これまで探索したことのない道を見逃してしまう可能性があることを意味します。これを避けるために、学習者はランダムな項目を追加することがありますが、必ずしも最適な項目が追加されるとは限りません。トレーニング方法は次のように定義できます。

 def train(モデル,エポック):
    ＃ 電車
    #勝利カウンターのリセット
    勝利数 = 0
    # AIの進捗状況を時間経過とともに追跡したいので、勝利回数の履歴を保存します
    勝利履歴 = []
    #エポックは私たちがプレイするゲームの数です
eが範囲(エポック)内である場合:
        損失 = 0。
        #ゲームのリセット
        env.reset()
        game_over = False  
        # 初期入力を取得する
        入力t = env.observe() 
         
        ゲームオーバーではない場合:
            #学習者は最後に観察したゲーム画面で行動している
            #input_tはゲーム画面を表すベクトルです
            入力tm1 = 入力t 
             
            #ランダムなアクションを実行する 確率イプシロン
            np.random.rand() <= epsilon の場合:
                #メニューからランダムに何か食べる
アクション= np.random.randint(0, num_actions,サイズ= 1)
それ以外：
                #自分で選ぶ
                #qには、アクションに対する期待報酬が含まれます
                q = モデル.予測(input_tm1)
                #私たちが行動を選ぶ 最も高い期待報酬
アクション= np.argmax(q[0]) 
 
            #アクションを適用し、報酬と新しい状態を取得します
            input_t、報酬、game_over = env.act(アクション)
            #果物を捕まえることができたら、勝利カウンターに1を加えます
            報酬 == 1 の場合:
                勝利数 += 1 
             
            #ここでゲームをレンダリングするには、コメントを解除します
            #display_screen(アクション,3000,入力[0]) 
             
 「」 「 」
            ゲームプレイ中に得られる経験 < s、a、r、s' > がトレーニング データになります。
            ここではまず前回の経験を保存し、  それから モデルをトレーニングするために、一連の経験をロードする
「」 「 」 
             
            #店舗体験
            exp_replay.remember([input_tm1,アクション, 報酬, input_t], ゲームオーバー) 
             
            #エクスペリエンスのバッチをロードする
            入力、ターゲット = exp_replay.get_batch(モデル、batch_size=batch_size) 
   
            #経験に基づいてモデルをトレーニングする
            batch_loss = model.train_on_batch(入力、ターゲット) 
             
            #エポック内のすべてのバッチの損失を合計します
            損失 += バッチ損失
        win_hist.append(win_cnt)
 win_histを返す