メインコンテンツへスキップ
見出し画像

Gymで強化学習⑳Q学習と線形近似

    前回は、連続値をとる状態の処理を関数近似によって行う方法について解説しました。今回はGymのカートポール(CartPole-v1)の環境を使ったQ学習の実装を線形近似を使って行います。

    画像
    CartPole-v1

    カートポールのルール

    カートポールの環境ではカートを左右に動かすことでポールのバランスをできるだけ長く保つことを目指します。

    行動

    行動としては2つの選択肢があります。

    • 0:カートを左へ押す

    • 1:カートを右へ押す

    ただし、どのくらいの力が左あるいは右に加えられるのかは固定されておらず、その都度ランダムに決まります。よってエージェントはポールの傾きなどを考慮して行動を決める必要があります。

    観測値

    観測できるデータは、4つの数値を要素としてもつベクトルになっています。

    • 要素1:カートの位置(-4.8から+4.8)

    • 要素2:カートの速度(負の無限大から正の無限大)

    • 要素3:ポールの角度(ラジアンで、-0.418から+0.418。角度で解釈すると-24度から+24度まで)

    • 要素4:ポールの角速度(負の無限大から正の無限大)

    カートの初期位置は、-0.05から+0.05の間でランダムに決まります。

    例えば、次のような観測値が与えられます。

    [-0.00131049  0.0047364   0.04382138  0.04789533]
    • カートの位置:-0.00131049 (中央からちょっと左の位置)

    • カートの速度:0.0047364 (右方向へ移動している)

    • ポールの角度:0.04382138 (時計回り右へ傾いている)

    • ポールの角速度:0.04789533 (時計回り右へ倒れている)

    この場合、ポールが右へ倒れ始めているので、カートを右に押してバランスを取る必要があります。

    画像
    ポールが右へ倒れ始めている(青)のでカートを右に押してバランスを取る(赤)

    報酬

    報酬は、各ステップごとに+1を与えられます。つまり、できるだけ長くポールを立たせることで総報酬を大きく増やすことができます。

    終了条件

    エピソードの終了の条件は、以下になります。

    • カートの位置が-2.4から+2.4の範囲の外になったら終了

    • カートの角度が-0.2095から+0.2095の範囲(±12°)の外になったら終了

    • エピソードのステップ数が500(報酬が500)になったら終了

    なお、エピソードの終了には、terminated と truncated があります。

    • カートの位置や角度が決められた範囲を超えた場合は、terminated となります。つまりは失敗です。

    • エピソードのステップ数が500に到達するとtruncated(切り捨て、時間切れ)となり終了しますが、こちらは成功とみなされます。

    terminated と truncatedの違いは行動価値の計算に影響するので覚えておいてください。

    なお、この環境に関する情報は、Cart Pole - Gymnasium Documentation (farama.org)にあります。

    Python環境の設定

    今回は新しいGymの環境を使うので、Pythonの環境から解説します。

    # テスト用のフォルダを作る
    mkdir cartpole
    cd cartpole
    
    #Pythonの環境を作る
    python3 -m venv venv
    source venv/bin/activate
    
    # Pipを最新のものにしておく
    pip install --upgrade pip
    
    # ジムをインストール (classic-control)
    pip install gymnasium[classic-control]

    Gymをインストールする際に classic-control と指定しています。これによって、カートポールの環境が必要とする依存関係がインストールされます。

    環境オブジェクトの作成などは、以前に「凍った湖」の環境でも解説したものと同様なので、ここで解説を割愛します。

    エージェントの実装

    エージェントのクラスはいつものように、いくつかのメソッドを定義することでエピソードを実行することができるようにしています。

    今回は線形近似を行うので LinearAgent と名付けました。

    class LinearAgent:
        def __init__(self, env, ...):
            # エージェントの初期化
            ...
    
        def reset(self, observation, info):
            # 状態の初期化
            ...
    
        def act(self):
            # 行動を選択する
            ...
    
        def learn(self, observation, reward, terminated, truncated, info):
            # 観測値、報酬などを受け取る
            ...

    それぞれのメソッドの実装を一つずつ見ていきます。

    初期化

    エージェントの初期化は次のようになっています。

        def __init__(self, env, alpha, gamma, epsilon, epsilon_decay):
            # エージェントの初期化
            self.env = env
            self.alpha = alpha
            self.gamma = gamma
            self.epsilon = epsilon
            self.epsilon_decay = epsilon_decay
    
            # 線形近似の重み
            self.weights = np.ones(3)

    これまで同様で、このエージェントではイプシロン・グリーディを使っています。よって、epsilon(イプシロン)、epsilon_decay(イプシロンの低減率)があります。

    また、行動価値のターゲットを計算する際の gamma(割引率)もあります。行動価値を更新する際の alpha(ステップサイズ)もこれまで通りです。

    唯一異なるのは、最後に線形近似の重み(パラメータ)を初期化していることです。今回は、3つのパラメータで行動価値の近似を行います。これについては後述します。

    リセット

    エージェントのリセットはエピソードが始まる際に呼ばれます。

        def reset(self, observation, info):
            # 状態の初期化
            self.state = observation
            self.total_reward = 0
            self.squared_errors = []

    ここでは、観測値を状態として保持し、エピソード内の報酬総和と二乗誤差を記録する変数を初期化しています。

    行動

    行動のメソッドでは、現在の状態に対する行動を選択し、それをメンバー変数に保持しています。また、その行動の値を返しています。

        def act(self):
            self.action = self._choose_action(self.state)
            return self.action

    ここで self._choose_action を呼び出しているのは、これまでのSARSAやQ学習の実装と合わせているからです。

    実際には、self._choose_action を別のメソッドにする必要はないのですが、後でSARSAの実装をしたい時のために、分けておいた方が比較・変更しやすく便利ではあります。

    なお、self._choose_action は次のようにイプシロン・グリーディの実装になっています。これも過去に見た実装とほぼ一致しています。

        def _choose_action(self, state):
            # 行動を選択する
            if np.random.random() < self.epsilon:
                # ランダムに行動を選択する
                action = np.random.choice(self.env.action_space.n)
            else:
                # 最大値の行動を選択する
                q_values = [self._q_value(state, a) for a in range(self.env.action_space.n)]
                action = np.argmax(q_values)
            return action

    以前のQ学習の実装と異なるのは、最大行動価値を与える行動を選ぶ際に、2つ以上の行動が同じ最大価値を持つ場合を考慮していない点です。

    action = np.argmax(q_values)

    これは、後で見るように self._q_value メソッドが関数近似を行なっており、経験していない状態と行動の組み合わに対しても、常に何らかの値を返すからです。

    これは、Q値を2次元配列などで処理していた場合とは異なります。以前は、経験がない状態行動の組み合わせに対して0などで初期化していたので、経験していないために同じ行動価値を返すことが頻繁に起こりました。よって、同じ最大行動価値を返す行動の間でランダムな選択を行なっていました。

    # 以下は関数近似をしている場合は必要なし
    
    # 最大値の行動が複数ある場合はランダムに選択する
    max_q_value = np.max(self.Q[state])
    max_q_value_indices = np.nonzero(self.Q[state] == max_q_value)[0]
    action = np.random.choice(max_q_value_indices)

    しかし、行動価値の関数近似を行う場合では、すべてのケースにおいて何らかの値が計算されるので、重複について調べることをしていません。(逆にもし重複が頻発するなるならば、関数近似の実装を見直すべきです)

    学習

    このメソッドはちょっと長いので、各セクションごとに解説します。

        def learn(self, observation, reward, terminated, truncated, info):
            # 観測値、報酬などを受け取る
            self.total_reward += reward
            next_state = observation

    まずは、受け取った報酬を、総報酬に追加します。そして、受け取った観測値を次の状態の変数に保持します。

    次に、ターゲットの行動価値を計算します。これは以前のQ学習と同じ実装です。

            # ターゲットの計算
            if terminated:
                target = reward
            else:
                # Q学習:オフポリシーの行動選択
                q_values = [self._q_value(next_state, a) \
                            for a in range(self.env.action_space.n)]
                target = reward + self.gamma * max(q_values)

    terminated の時は失敗して終わるので、次の状態からの価値はゼロであるため、ターゲットは受け取った報酬のみになります。

            if terminated:
                target = reward
            else:
                ...

    失敗していない場合(通常のステップの場合と truncated になって終了する場合)は、将来から受け取る報酬の予測を計算して、その最大値を割引したものを報酬に足し合わせています。

            else:
                # Q学習:オフポリシーの行動選択
                q_values = [self._q_value(next_state, a) \
                            for a in range(self.env.action_space.n)]
                target = reward + self.gamma * max(q_values)

    self._q_value メソッドは行動価値の予測をしています。これをすべての行動 a に対して計算したものが q_values です。なお、self.env.action_space.nは行動の数を返すので、それを使ってすべての行動の値に対してループをしています。

    max(q_values) で得た最大値を self.gamma で割引したものを報酬 reward に追加したものが、行動価値のターゲットになります。

    ちなみに、以下のように変えると、SARSAの実装になります。SARSAではターゲットにするポリシーと挙動ポリシーが同じだからです。

            else:
                # SARSA
                next_action = self._choose_action(next_state)
                target = reward + self.gamma * self._q_value(next_state, next_action)
     

    Q学習でもSARSAでも、このターゲットの値を計算する際に、self._q_value メソッドによる予測値を使っています。よって、ターゲットの計算でブートストラッピング(以前の予測値を使って、新しい予測をする)が行われています。

    ターゲットの値は新しい情報を取り入れた場合のQ値の予測になります。これと比較するために、新しい情報を取り入れる以前の予測によるQ値も計算します。

            # 現在のQ値の計算
            q_value = self._q_value(self.state, self.action)

    状態が有限な場合は、ディクショナリや2次元配列を使っていました。しかし、カートポールの環境における状態では連続値を扱うので近似的な解決法で解説をした関数近似を使っています。詳細は後述します。

    ターゲットとQ値の予測が計算できたらTDエラーが計算できます。

            # TD誤差の計算
            error = target - q_value

    このTDエラーがわかるとパラメータの更新ができます。

            # 重みの更新
            self.weights += self.alpha * error * \
                            self._features(self.state, self.action)

    これは、前回の記事で解説した更新式の実装ですが、詳しくは後述します。

    あとは、エピソードの終了時にイプシロンの値を低減させます。

            # 状態の更新
            self.state = next_state
    
            # エピソード終了処理
            if terminated or truncated:
                ...
    
                # イプシロンを徐々に減らしていく
                self.epsilon *= self.epsilon_decay

    以上でエージェントの実装の全体像の解説になります。

    次に「後述します」となっている部分を解説します。

    線形近似の実装

    パラメータの更新

    一般にパラメータの更新は次のように定義されていました。

    wt+1←wt+α[q(st,at)−q^(st,at,wt) ]∇ q^(st,at,wt)\boldsymbol{w}_{t+1} \leftarrow \boldsymbol{w}_t + \alpha \left[ q(\boldsymbol{s}_t, a_t) - \hat{q}(\boldsymbol{s}_t, a_t, \boldsymbol{w}_t)  \right] \nabla \hat{q}(\boldsymbol{s}_t, a_t, \boldsymbol{w}_t)

    α\alphaはステップサイズで、q(st,at)−q^(st,at,wt)q(\boldsymbol{s}_t, a_t) - \hat{q}(\boldsymbol{s}_t, a_t, \boldsymbol{w}_t)はTDエラーです。

    ここで、2つの特徴量x1,x2x_1, x_2があるとします。すると、ある行動at=aa_t = aに対して、線形関数で近似するのに必要なパラメータはw1,w2,w3w_1, w_2, w_3(w3w_3はバイアスです)となります。

    よって、ある行動at=aa_t = aに対する行動価値関数は次のようになります。

    q^(st,at=a,wt)=w1x1+w2x2+w3\hat{q}(\boldsymbol{s}_t, a_t=a, \boldsymbol{w}_t) = w_1 x_1 + w_2 x_2 + w_3

    各パラメータにおける行動価値関数の勾配は次のようになります。

    ∇ q^(st,at=a,wt)=(x1,x2,1)\nabla \hat{q}(\boldsymbol{s}_t, a_t=a, \boldsymbol{w}_t) = (x_1, x_2, 1)

    つまり、線形近似を行った場合の勾配は特徴量のみによって決まります。

    特徴量の計算

    ある行動at=aa_t = aに対する特徴量は状態st\boldsymbol{s}_tから計算されるので、

    x1=f1(st)x2=f2(st) \begin{aligned} x_1 &= f_1(\boldsymbol{s}_t) \\ x_2 &= f_2(\boldsymbol{s}_t) \ \end{aligned}

    となります。

    ただし、今回の実装では、特徴量の計算を行動ごとに分けるのではなく、状態st\boldsymbol{s}_tと行動ata_tを両方考慮して計算しています。

    x1=f1(st,at)x2=f2(st,at) \begin{aligned} x_1 &= f_1(\boldsymbol{s}_t, a_t) \\ x_2 &= f_2(\boldsymbol{s}_t, a_t) \ \end{aligned}

    こうすることで、共通のパラメータをすべての状態と行動に関して使うことができるので実装が単純になります。また、学習するパラメータの数が減る(行動ごとに分ける必要がない)ので効率良い学習が期待されます。

    ソースコードでは次のようになっており、特徴量のベクトルを返しています。

        def _features(self, state, action):
            # 状態と行動から特徴量を計算する
            action = -1 if action==0 else 1
            return np.array([
                action * state[2],   # 行動とカートポールの角度の積
                action * state[3],   # 行動とカートポールの角速度の積
                1,                   # バイアス項
            ])

    ここでどの状態値を使うのかは、人間(私)が試行錯誤して決めています。

    状態ベクトル state の要素値を色々と試したのちに、一番重要なのは角度と角速度とその時の行動の向きだと考え上記のようにしました。

    まず、行動の値は0と1で左右へのプッシュになっていますが、計算の都合上、−1と1とした方が便利なのでそう変換しいます。

            action = -1 if action==0 else 1

    例えば、角度が負の値の場合は、ポールが左寄りに傾いており、その際はカートを左に押すほうがバランスが取れるます。よって、角度と行動の向きが同じ方が行動価値が高くなるはずなので、以下の特徴量を考えました。

                action * state[2],   # 行動とカートポールの角度の積

    ポールの傾きとカートを押す方向が合えば、上記の値は正の値になります。

    よって、右に倒れるポールのバランスを取るにはカートを右に押す。また、左に倒れるポールのバランスを取るにはカートを左に押す、といった行動を促すことになります。

    さらに、ポールの傾きとカートを押す方向が異なれば、上記の値は負の値になります。

    つまり、右に倒れるポールに対してカートを左に押す。あるいは、左に倒れるポールに対してカートを右に押す、ことになりバランスをさらに崩すことになります。よってこのような行動は敬遠されることになります。

    また、各速度についても同様に考えました。

                action * state[3],   # 行動とカートポールの角速度の積

    あとは、バイアス項のために1を付け足したものを特徴量ベクトルとしてNumPyの配列にして返しています。

            return np.array([
                action * state[2],   # 行動とカートポールの角度の積
                action * state[3],   # 行動とカートポールの角速度の積
                1,                   # バイアス項
            ])

    なお、注意した点としては、たくさんの特徴量を作りすぎると、近似するための関数が使うパラメータの数が増えすぎて、学習がうまくいかない可能性が高くなるのでなるべく少ない特徴量で、しかも線形近似でうまくいきそうなものを考えました。

    ある状態において、異なる行動の価値を相対的に表現できれば、行動選択に役立つので、そのことを念頭に試行錯誤し特徴量を決めました。

    ちなみに、特徴量の計算はこのメソッドでのみ行なっているので、このコードを変更するだけでいろいろな特徴量を試すことができます。ぜひ、実験されることを勧めます。

    なお、バイアス項を含めた特徴量の数を変更する場合は、エージェントの初期化でパラメータの数を指定しているので、そこも変更する必要があります。

        def __init__(self, env, alpha, gamma, epsilon, epsilon_decay):
            # エージェントの初期化
         ...
    
            # 線形近似の重み
            self.weights = np.ones(3)

    また、パラメータの初期値として np.ones を使っているのですべて1に設定されています。この理由は、パラメータをすべてゼロにすると特徴量によらずに行動価値が最初はゼロになってしまうことを防ぐためです。

    必ず1である必要はないので、パラメータの初期化にランダムな値などを使って実験してみると面白いかもしれません。ニューラルネットワークなどを使う場合はパラメータの重みの初期化についても考える必要がありますが、今回は特に拘りませんでした。よって、シンプルなものを選びました。

    特徴量が決まれば、Q値の計算ができます。

    Q値の計算

    Q値の計算はパラメータ(重み)ベクトルと特徴量ベクトルの内積として計算しています。

        def _q_value(self, state, action):
            # Q値を計算する
            return np.dot(self.weights, self._features(state, action))

    やっていることは前述した線形関数の計算式と同じです。

    (w1,w2,w3)⋅(x1,x2,1)=w1x1+w2x2+w3(w_1, w_2, w_3) \cdot (x_1, x_2, 1) = w_1 x_1 + w_2 x_2 + w_3

    以上が線形近似の実装の解説になります。次に、ソースコードのリストと実行の仕方を解説します。

    ソースコードの実行

    ソースコード

    import argparse
    import gymnasium as gym
    import numpy as np
    
    
    class LinearAgent:
        def __init__(self, env, alpha, gamma, epsilon, epsilon_decay):
            # エージェントの初期化
            self.env = env
            self.alpha = alpha
            self.gamma = gamma
            self.epsilon = epsilon
            self.epsilon_decay = epsilon_decay
    
            # 線形近似の重み
            self.weights = np.ones(3)
    
        def reset(self, observation, info):
            # 状態の初期化
            self.state = observation
            self.total_reward = 0
            self.squared_errors = []
    
        def act(self):
            self.action = self._choose_action(self.state)
            return self.action
    
        def _choose_action(self, state):
            # 行動を選択する
            if np.random.random() < self.epsilon:
                # ランダムに行動を選択する
                action = np.random.choice(self.env.action_space.n)
            else:
                # 最大値の行動を選択する
                q_values = [self._q_value(state, a) for a in range(self.env.action_space.n)]
                action = np.argmax(q_values)
            return action
    
        def learn(self, observation, reward, terminated, truncated, info):
            # 観測値、報酬などを受け取る
            self.total_reward += reward
            next_state = observation
            
            # ターゲットの計算
            if terminated:
                target = reward
            else:
                # Q学習:オフポリシーの行動選択
                q_values = [self._q_value(next_state, a) \
                            for a in range(self.env.action_space.n)]
                target = reward + self.gamma * max(q_values)
    
            # 現在のQ値の計算
            q_value = self._q_value(self.state, self.action)
    
            # TD誤差の計算
            error = target - q_value
    
            # 重みの更新
            self.weights += self.alpha * error * self._features(self.state, self.action)
    
            # エラーの記録
            self.squared_errors.append(error**2)
    
            # 状態の更新
            self.state = next_state
    
            # エピソード終了処理
            if terminated or truncated:
                print(f'総報酬  : {self.total_reward:6.2f}')
                print(f'イプシロン: {self.epsilon:6.2f}')
                print(f'角度   : {self.state[2] * 180 / np.pi:6.2f}')
                print(f'位置   : {self.state[0]:6.2f}')
                for i, w in enumerate(self.weights):
                    print(f'重み{i}   : {w:8.4f}')
                mse = np.mean(self.squared_errors)
                print(f'エラー平均: {mse:8.4f}')
                print()
    
                # イプシロンを徐々に減らしていく
                self.epsilon *= self.epsilon_decay
    
        def _q_value(self, state, action):
            # Q値を計算する
            return np.dot(self.weights, self._features(state, action))
        
        def _features(self, state, action):
            # 状態と行動から特徴量を計算する
            action = -1 if action==0 else 1
            return np.array([
                #state[0],           # カートポールの位置
                #state[1],           # カートポールの速度
                #state[2],           # カートポールの角度
                #state[3],           # カートポールの角速度
                #action * state[0],  # 行動とカートポールの位置の積
                #action * state[1],  # 行動とカートポールの速度の積
                action * state[2],   # 行動とカートポールの角度の積
                action * state[3],   # 行動とカートポールの角速度の積
                1,                   # バイアス項
            ])
    
    
    def run_episodes(env, agent, max_episodes):
        # エピソードのループをmax_episodes回繰り返す
        for episode in range(max_episodes):
            print(f'エピソード: {episode+1}')
    
            # ゲーム環境を初期化してエージェントに初期観測値を渡す
            observation, info = env.reset()
            agent.reset(observation, info)
    
            # 1つのエピソードのループ
            while True:
                # エージェントの行動を決定
                action = agent.act()
    
                # 行動を実行すると、環境の状態が更新される
                observation, reward, terminated, truncated, info = env.step(action)
    
                # エージェントの学習
                agent.learn(observation, reward, terminated, truncated, info)
    
                # ゲームが終了したら、次のエピソードへ
                if terminated or truncated:
                    break
    
        # 環境を閉じる
        env.close()
    
    
    def main():
        # コマンドライン引数を取得
        parser = argparse.ArgumentParser()
        parser.add_argument("--alpha"        , type=float, default=0.01)
        parser.add_argument("--gamma"        , type=float, default=0.9)
        parser.add_argument("--epsilon"      , type=float, default=1.0)
        parser.add_argument("--epsilon_decay", type=float, default=0.99)
        parser.add_argument("--max_episodes" , type=int  , default=1000)
        parser.add_argument("--no_render"    , action="store_true")
        args = parser.parse_args()
        args.render_mode = "human" if not args.no_render else None
        print(args)
    
        # 環境を作成
        env = gym.make('CartPole-v1', render_mode=args.render_mode)
        
        # エージェントを作成
        agent = LinearAgent(env,
                           alpha=args.alpha,
                           gamma=args.gamma,
                           epsilon=args.epsilon,
                           epsilon_decay=args.epsilon_decay)
    
        # エピソードを実行
        run_episodes(env, agent, max_episodes=args.max_episodes)
    
    
    if __name__ == "__main__":
        main()
    

    実行の仕方

    ソースコードを cartpole_linear.py といったファイルにセーブしておきます。

    実行する前に、前述したPython環境を有効にしておいてください。

    なお、実行する際に幾つかのパラメータを指定できます。

    usage: cartpole_linear.py [-h] [--alpha ALPHA] [--gamma GAMMA]
                              [--epsilon EPSILON] [--epsilon_decay EPSILON_DECAY]
                              [--max_episodes MAX_EPISODES] [--no_render]
    
    options:
      -h, --help            show this help message and exit
      --alpha ALPHA
      --gamma GAMMA
      --epsilon EPSILON
      --epsilon_decay EPSILON_DECAY
      --max_episodes MAX_EPISODES
      --no_render

    デフォルトの値で実行するには、次のようにします。

    python cartpole_linear.py

    画像なしで高速に実行したい場合は、次のように実行します。

    python cartpole_linear.py --no_render

    これでもコンソールに総報酬などがエピソードごとに表示されるので更新される様子がわかります。

    実行結果

    パラメータの収束値

    1000エピソードで実行していますが、150エピソードぐらいから500ステップ達成するケースが増えていきます。

    その後も、パラメータの値が変化し続けますが、最終的には次のような値に収束します。

    エピソード: 1000
    総報酬  : 500.00
    イプシロン:   0.00
    角度   :  -0.24
    位置   :   0.60
    重み0   :   0.6213
    重み1   :   0.0162
    重み2   :   9.9957
    エラー平均:   0.0000

    見ての通り、総報酬は500を達成しており学習がうまくいっているのがわかります。

    なお、ここでの角度はラジアンから度数にしたものを表示しています。ほぼ直立で終わっているのがわかります。

    重みに関しては、角度(重み0)の方が角速度(重み1)よりも重要なのがわかります。

    バイアスの値

    バイアス(重み2)が10に近い値なのは、興味深いところです。今回の実装では、バイアス項に関しては、行動に関わらず共通になっているので、ゼロでも良さそうですが、そうなっていません。

    試しに、バイアス項なしで近似を行うと学習がうまく収束しません。

    バイアスが意味するところは、特徴量がすべて0の時の行動価値です。つまり、角度が0で角速度が0ならば特徴量がすべて0なのでバイアスの値が行動価値になります。これは、ポールが完全に直立して静止している状況です。

    この環境では行動として「何もしない」というオプションはないのですが、カートを左右に動かすことで平均的にポールが静止していると考えると、500ステップにおける生涯報酬を報酬r=1r=1で割引率γ=0.9\gamma=0.9を考慮して次のように計算できます。

    g=γ0r+γ1r+γ2r+⋯+γ499 rg = \gamma^0 r + \gamma^1 r + \gamma^2 r + \dots + \gamma^{499} r

    γ0\gamma^0は現在の報酬だから割引なしという意味です。また、以下では、r=1r=1なのでrrを省略します。

    この両辺をγ\gamma倍して差を計算することでggの式を単純化します。

    g=γ0+γ1+γ2+⋯+γ499γg=γ1+γ2+γ3+⋯+γ500\begin{aligned} g &= \gamma^0 + \gamma^1 + \gamma^2 + \dots + \gamma^{499} \\ \gamma g &= \gamma^1 + \gamma^2 + \gamma^3 + \dots + \gamma^{500} \end{aligned}

    よって、

    g−γg=γ0−γ500(1−γ)g=1−γ500 g=1−γ5001−γ\begin{aligned} g - \gamma g &= \gamma^0 - \gamma^{500} \\ (1-\gamma)g &= 1 - \gamma^{500}  \\ g & = \frac{1-\gamma^{500}}{1-\gamma} \end{aligned}

    となります。なお、γ0=1\gamma^0=1であることを使っています。

    これをPythonで計算します。

    r = 1
    gamma = 0.9
    n = 500
    
    g = r * (1 - gamma**n) / (1 - gamma)
    
    print(g)

    これを実行すると、10.000000000000002 という値になります。

    行動価値の予測としては500ステップによる制限を考慮していないので、n→∞n \rightarrow \inftyで無限ステップを考えると、上式は次のようになります。

    g=r11−γg = r \dfrac{1}{1-\gamma}

    r=1r=1とγ=0.9\gamma=0.9を代入すると、g=10g=10になります。

    実際にポールを完全静止できないのに、バイアスの値がこれに近くなっているのはちょっと驚きですが、近似による行動価値の予測がうまくいっている証拠でもあります。

    まとめ

    今回は、カートポールの環境で線形近似によるQ学習の実装を行いました。そもそも線形近似がうまくいきそうな単純な環境を選んでいます。

    しかし、特徴量を決める際に人間による試行錯誤が必要です。結果としてうまくいっていますが、今回使った特徴量よりも良いものがあるかもしれません。

    なので、状態行動の値の間により複雑な関係がある場合は、ニューラルネットワークなどを使って特徴量自体を学習させるという手法があります。

    次回は、ニューラルネットワークを近似関数として使うことについて解説します。

    (続く)

     
     
    「わかりやすく、具体的に」AIとサイエンスの情報を発信中

    あなたへのおすすめ