強化学習のしくみ：Q 学習から DQN・AlphaGo・PPO まで

強化学習は、正解を教えてもらうのではなく、自分で行動してみて、その結果もらえる「報酬」を手がかりに、良い行動のしかたを学ぶ機械学習の方法です。囲碁で世界のトップ棋士に勝った AlphaGo、ゲームの画面だけを見て遊び方を覚える AI、ロボットの歩き方の学習、そして ChatGPT を人の好みに合う答え方に仕上げる RLHF にも使われています。

この記事は 画像分類 AI のしくみ などに続く、機械学習の入門の記事です。これまでの記事は、画像と正解のラベルの組から学ぶ「教師あり学習」でしたが、強化学習には正解のラベルがありません。ニューラルネットワーク・勾配降下法は画像分類の記事で説明したので、この記事では「報酬からどう学ぶか」に絞ります。

結論を先に書くと、強化学習は次の考え方でできています。

• 将来もらえる報酬の合計を最大にする: 目先の報酬だけでなく、あとでもらえる報酬も、割り引いて足し合わせた値を大きくする
• 価値を見積もる: 「この状態でこの行動を取ると、将来どれだけ報酬がもらえそうか」を表す Q 値を、ベルマン方程式を手がかりに少しずつ直していく（Q 学習）
• 探索と活用のバランスを取る: 今いちばん良さそうな行動ばかり取ると、もっと良い行動を見逃す。ときどきあえて別の行動を試す
• 大きな問題ではニューラルネットワークを使う: 状態が多すぎて表にできないときは、価値や方策（行動の選び方）をニューラルネットワークで表す（DQN・方策勾配法・PPO）

説明の途中に出てくる計算例は、Python と NumPy で実際に動かした結果です。

環境

計算例を動かした環境です。

項目	バージョン
Python	3.13
NumPy	2.5

強化学習とは：行動して報酬から学ぶ

エージェントと環境のやり取り

強化学習では、学ぶ側を エージェント、エージェントが働きかける相手を 環境と呼びます。両者は次のやり取りをくり返します。

1. エージェントが、環境の今の 状態（盤面・画面・ロボットの姿勢など）を見る
2. エージェントが 行動を 1 つ選ぶ（石を置く・ボタンを押す・関節を動かす）
3. 環境が次の状態に変わり、エージェントに 報酬（数値）を渡す

ゲームなら、勝てば +1・負ければ −1、迷路なら 1 歩ごとに −1（早くゴールするほど良い）、のように報酬を決めます。エージェントが状態から行動を選ぶ決まりを 方策（policy）と呼び、強化学習の目標は、報酬が多くもらえる方策を見つけることです。

教師あり学習との違い

	教師あり学習	強化学習
学ぶ材料	入力と正解の組	自分で行動した結果の報酬
正解	1 つ 1 つの入力に正解がある	「どの行動が正しかったか」は教えてもらえない
結果が分かる時期	すぐ	何手も先（囲碁なら最後の勝敗だけ）
データ	最初から決まっている	自分の行動しだいで集まるデータが変わる

いちばん難しいのは、報酬が何手もあとにしか来ないことです。囲碁で負けたとき、200 手のうちどの手が悪かったのかは分かりません。これを 信用割り当て問題と呼びます。

収益と割引率

強化学習で最大にするのは、1 回の報酬ではなく、これから先にもらえる報酬の合計です。これを 収益（return）と呼びます。ただし、遠い将来の報酬ほど割り引いて足します。割り引く割合 γ（ガンマ）を 割引率と呼び、0〜1 の値を使います。

G = r₁ + γ r₂ + γ² r₃ + γ³ r₄ + …

3 歩は報酬なしで、4 歩目にゴールして 10 もらえる場合の収益を、割引率を変えて計算してみます。

rewards = [0, 0, 0, 10]  # 3 歩は何もなく、4 歩目にゴールで 10
for gamma in [1.0, 0.9, 0.5]:
    G = sum(gamma**k * r for k, r in enumerate(rewards))
    print(gamma, round(G, 3))

実行結果:

1.0 10.0
0.9 7.29
0.5 1.25

γ = 1 なら割り引かずに 10 のまま、γ = 0.9 なら 0.9³ 倍の 7.29、γ = 0.5 なら 1.25 です。割引率が小さいほど、遠くの報酬を軽く見る「せっかち」なエージェントになり、同じ報酬なら早くもらえる道を好むようになります。

探索と活用：スロットマシンで考える

多腕バンディット問題

状態が 1 つしかない、いちばん簡単な強化学習の問題から始めます。当たりやすさの違う 10 台のスロットマシンがあり、どれか 1 台を選んで引くと、その台の平均のまわりでばらつく報酬がもらえます。1,000 回引いて、もらえる報酬の合計をなるべく大きくしたい、という問題です。多腕バンディット問題と呼ばれます。

どの台が良いかは、引いてみないと分かりません。ここで次の 2 つがぶつかります。

	内容	やりすぎると
活用（exploitation）	今までの結果でいちばん平均の良い台を引く	たまたま最初に当たった台にこだわり、本当に良い台を見逃す
探索（exploration）	あまり試していない台を引いてみる	悪いと分かっている台を何度も引いて損をする

ε-greedy：ときどきランダムに試す

いちばん簡単な方法は ε-greedy です。確率 ε でランダムな台を選び（探索）、それ以外は今の見積もりでいちばん良い台を選びます（活用）。台の平均の報酬をランダムに決めた問題を 2,000 回作り、それぞれ 1,000 回引いた結果を ε ごとに比べてみます（この環境では実行に 1 分半ほどかかりました）。

import numpy as np

def run_bandit(epsilon, steps=1000, runs=2000, seed=0):
    rng = np.random.default_rng(seed)
    total = 0.0
    best = 0
    for _ in range(runs):
        true_means = rng.standard_normal(10)        # 10 台のスロットの本当の平均
        q = np.zeros(10)                              # 見積もった平均
        n = np.zeros(10)
        for _ in range(steps):
            if rng.random() < epsilon:
                a = rng.integers(10)                  # 探索：ランダムに選ぶ
            else:
                a = rng.choice(np.flatnonzero(q == q.max()))  # 活用：今いちばん良いもの
            r = true_means[a] + rng.standard_normal()
            n[a] += 1
            q[a] += (r - q[a]) / n[a]
            total += r
        best += a == true_means.argmax()
    return total / (runs * steps), best / runs

for eps in [0.0, 0.01, 0.1]:
    avg, best = run_bandit(eps)
    print(eps, round(avg, 3), round(best, 3))

実行結果:

0.0 1.018 0.34
0.01 1.174 0.596
0.1 1.299 0.785

左から ε、1 回あたりの平均の報酬、1,000 回目に本当にいちばん良い台を引いていた割合です。まったく探索しない ε = 0 では、いちばん良い台にたどり着けたのは 34% だけでした。最初に少し良い結果が出た台にこだわってしまうからです。ε = 0.1 では 78.5% がいちばん良い台を見つけ、平均の報酬も最も高くなりました。

q[a] += (r - q[a]) / n[a] の行は、平均を少しずつ更新する計算です。「見積もり ← 見積もり + 割合 × （新しい結果 − 見積もり）」という形は、このあとの Q 学習でも同じ形で出てきます。

価値関数とベルマン方程式

状態の価値と行動の価値

状態がいくつもある問題では、「どの状態にいるのが良いか」を数値で表す 価値を考えます。

価値	意味
状態価値 V(s)	状態 s から、ある方策に従って行動したときにもらえる収益の期待値
行動価値 Q(s, a)	状態 s で行動 a を取り、そのあとはある方策に従ったときにもらえる収益の期待値（Q 値）

いちばん良い方策での Q 値 Q*(s, a) が分かれば、各状態で Q* が最大の行動を選ぶだけで、いちばん良い行動ができます。

ベルマン方程式：今の価値を 1 歩先の価値で表す

Q* は次の式を満たします。これを ベルマン最適方程式と呼びます（s′ は行動 a のあとの次の状態）。

Q*(s, a) = 報酬 r + γ × max Q*(s′, a′)

「今の行動の価値は、すぐもらえる報酬と、次の状態でいちばん良い行動を取ったときの価値（割り引いたもの）の和」という意味です。環境のしくみ（どの行動でどの状態に移り、報酬がいくつか）が分かっていれば、すべての状態と行動にこの式をくり返し当てはめて、Q* を求められます。これを 価値反復と呼びます。

崖歩きの問題で価値反復を解く

強化学習の定番の教科書（Sutton と Barto の『強化学習』）に出てくる 崖歩きの問題で計算してみます。幅 12・高さ 4 の格子の左下からスタートし、右下のゴールを目指します。スタートとゴールの間の下の段は崖で、落ちると −100 の報酬を受けてスタートに戻されます。それ以外は 1 歩ごとに −1 です。

import numpy as np

# 崖歩き：幅 12・高さ 4 の格子。左下がスタート、右下がゴール、その間の下の段が崖
W, H = 12, 4
START, GOAL = (3, 0), (3, 11)
MOVES = [(-1, 0), (1, 0), (0, -1), (0, 1)]  # 上・下・左・右

def step(s, a):
    r, c = s[0] + MOVES[a][0], s[1] + MOVES[a][1]
    r, c = min(max(r, 0), H - 1), min(max(c, 0), W - 1)
    if r == 3 and 1 <= c <= 10:  # 崖に落ちたらスタートに戻され、-100
        return START, -100, False
    return (r, c), -1, (r, c) == GOAL

# 価値反復：ベルマン方程式をくり返し当てはめて、正解の Q* を求める
Q_star = np.zeros((H, W, 4))
for sweep in range(100):
    new = np.zeros_like(Q_star)
    for r in range(H):
        for c in range(W):
            if (r, c) == GOAL:
                continue
            for a in range(4):
                s2, rew, done = step((r, c), a)
                new[r, c, a] = rew + (0 if done else Q_star[s2].max())
    if np.allclose(new, Q_star):
        break
    Q_star = new
print(sweep, Q_star[START].max())

実行結果:

15 -13.0

15 回更新したところで値が変わらなくなり、スタートでの最大の Q* は −13 になりました。崖のすぐ上を通って、上に 1 歩・右に 11 歩・下に 1 歩の 13 歩でゴールするのがいちばん良い、ということです（割引率は 1 にしています）。

ただし価値反復は、環境のしくみを全部知っていないと使えません。ゲームやロボットでは、行動の結果は実際にやってみないと分からないのがふつうです。

Q 学習と SARSA：やってみながら Q 値を直す

Q 学習

Q 学習は、環境のしくみを知らなくても、実際に行動して得た 1 歩ぶんの結果（状態 s で行動 a を取り、報酬 r をもらって状態 s′ に移った）だけで Q 値を直していく方法です。

Q(s, a) ← Q(s, a) + α × (r + γ × max Q(s′, a′) − Q(s, a))

かっこの中の r + γ × max Q(s′, a′) が、ベルマン方程式の右辺を 1 回の経験で見積もった「目標」で、Q 値をその目標に向けて学習率 α の割合だけ近づけます。スロットマシンの平均の更新と同じ形です。行動は ε-greedy で選び、ときどき探索します。

SARSA：次に実際に取る行動の値を使う

よく似た方法に SARSA があります。違いは目標の 2 項目だけです。

方法	目標	意味
Q 学習	r + γ max Q(s′, a′)	次の状態で「いちばん良い行動」を取ると仮定する
SARSA	r + γ Q(s′, a′)（a′ は次に実際に取る行動）	次の状態で「実際に選んだ行動」（探索のランダムな行動も含む）の値を使う

名前は、更新に使う 5 つの値（s, a, r, s′, a′）の頭文字から来ています。

崖歩きで 2 つを比べる

さきほどの崖歩きで、Q 学習と SARSA を 500 エピソード（スタートからゴールまでの 1 回の挑戦）ずつ学習させてみます。上のコードの続きです。

def choose(Q, s, eps, rng):
    if rng.random() < eps:
        return int(rng.integers(4))
    return int(rng.choice(np.flatnonzero(Q[s] == Q[s].max())))

def train(method, episodes=500, alpha=0.5, eps=0.1, seed=0):
    rng = np.random.default_rng(seed)
    Q = np.zeros((H, W, 4))
    returns = []
    for _ in range(episodes):
        s, total = START, 0
        a = choose(Q, s, eps, rng)
        for _ in range(1000):
            s2, rew, done = step(s, a)
            total += rew
            a2 = choose(Q, s2, eps, rng)
            if done:
                target = rew
            elif method == "q":
                target = rew + Q[s2].max()   # Q 学習：次の状態でいちばん良い行動の値
            else:
                target = rew + Q[s2][a2]     # SARSA：次に実際に取る行動の値
            Q[s][a] += alpha * (target - Q[s][a])
            s, a = s2, a2
            if done:
                break
        returns.append(total)
    return Q, np.mean(returns[-100:])

def greedy_path(Q):
    s, path = START, [START]
    while s != GOAL and len(path) < 50:
        s, _, _ = step(s, int(Q[s].argmax()))
        path.append(s)
    return path

for method in ["q", "sarsa"]:
    Q, avg = train(method)
    path = greedy_path(Q)
    print(method, round(float(avg), 1), len(path) - 1, min(r for r, _ in path[1:-1]))

実行結果:

q -60.0 13 2
sarsa -24.4 17 0

左から、方法、最後の 100 エピソードの収益の平均、学習した Q 値で探索せずに進んだときの歩数、そのとき通ったいちばん上の段の番号（0 が最上段、2 が崖のすぐ上）です。

• Q 学習は、価値反復の答えと同じ 13 歩の最短の道（崖のすぐ上の段）を学びました。ところが、学習中は ε = 0.1 でランダムな行動を混ぜているので、崖のすぐ上を歩くとたまに足をすべらせて落ち、収益の平均は −60 と悪くなっています
• SARSAは、ランダムな行動で落ちることも込みで Q 値を学ぶので、崖から離れた最上段を通る 17 歩の安全な道を選びました。歩数は多いものの、学習中の収益の平均は −24.4 で、Q 学習よりずっと良くなっています

「理屈の上での最短の道」を学ぶか、「自分の行動のくせ（探索）も込みで安全な道」を学ぶかの違いです。

このサイトの 強化学習（Q 学習）の可視化 では、この崖歩きを含む格子の世界で、Q 学習・SARSA・期待 SARSA を並べて学習させ、Q 値の色と方策の矢印が変わっていく様子を見られます。価値反復で求めた正解との差や、学習率・割引率・探索率を変えたときの違いも確かめられます。

DQN：ニューラルネットワークで Q 値を表す

状態が多すぎて表にできない

崖歩きの状態は 48 マスしかないので、Q 値を「状態の数 × 行動の数」の表で持てました。ところが、ゲームの画面を状態にすると、状態の数は桁違いに増えます。

import math

pixels = 84 * 84 * 4  # 84 × 84 の白黒画像を 4 枚重ねたもの
print(f"{pixels:,}", f"{pixels * math.log10(256):,.0f}")

実行結果:

28,224 67,970

84 × 84 画素・256 段階の白黒画像を 4 枚重ねると 28,224 個の画素になり、ありうる画面の数は 256 の 28,224 乗、つまり 10 の約 67,970 乗通りです。表で持つことはできず、同じ画面に 2 度出会うこともほとんどありません。

Q 値をニューラルネットワークで計算する

2013 年（論文誌には 2015 年）に DeepMind が発表した DQN（Deep Q-Network）は、画面を入力して行動ごとの Q 値を出す畳み込みニューラルネットワークで、この表を置き換えました。似た画面には似た Q 値を返すので、初めて見る画面でも行動を選べます。

ただし、Q 学習の目標を、学習中のネットワーク自身で計算すると、学習が不安定になります。DQN はこれを 2 つの工夫で抑えました。

工夫	内容
経験再生（experience replay）	経験（s, a, r, s′）をためておき、ランダムに取り出して学習する。続けて起きた、よく似た経験ばかりで学習するのを防ぐ
ターゲットネットワーク	目標の計算には、少し前の重みを固定したネットワークのコピーを使い、一定の間隔でだけ更新する。目標が毎回動くのを防ぐ

DQN は、Atari の 49 種類のゲームを、画面とスコアだけから同じ設定で学び、その多くで人間のプロのテスターに並ぶ成績を出しました。

方策勾配法と PPO：行動の選び方を直接学ぶ

方策勾配法：良かった行動の確率を上げる

Q 学習は価値を学んでから行動を決めましたが、方策勾配法は、行動を選ぶ確率（方策）そのものをニューラルネットワークで表し、収益が大きくなる向きにその重みを直接動かします。ロボットの関節の角度のように、行動が連続した値のときにも使いやすい方法です。

いちばん基本の REINFORCE は、「平均より良い報酬が出た行動の確率を上げ、悪かった行動の確率を下げる」という更新をします。比べる基準の「平均」を ベースラインと呼びます。3 つの行動（本当の平均の報酬は 1.0・2.0・1.5）から選ぶ問題で試してみます。

import numpy as np

rng = np.random.default_rng(0)
true_means = np.array([1.0, 2.0, 1.5])  # 3 つの行動の本当の平均の報酬
theta = np.zeros(3)                      # 方策のパラメーター（行動ごとの点数）
alpha, baseline = 0.1, 0.0
for t in range(1, 2001):
    pi = np.exp(theta) / np.exp(theta).sum()
    a = rng.choice(3, p=pi)
    r = true_means[a] + rng.standard_normal()
    baseline += (r - baseline) / t        # これまでの報酬の平均
    grad_log = -pi
    grad_log[a] += 1                      # log π(a) の勾配
    theta += alpha * (r - baseline) * grad_log
    if t in [1, 100, 500, 2000]:
        print(t, np.round(pi, 3))

実行結果:

1 [0.333 0.333 0.333]
100 [0.138 0.624 0.238]
500 [0.006 0.976 0.018]
2000 [0.001 0.994 0.004]

最初は 3 つの行動を 1/3 ずつ選んでいましたが、100 回目には平均の報酬がいちばん高い 2 番目の行動の確率が 0.624 に、2,000 回目には 0.994 まで上がりました。行動ごとの点数をソフトマックスで確率に変えるのは、画像分類のモデルの最後の層と同じです。

PPO：一度に方策を変えすぎない

方策勾配法は、1 回の更新で方策を大きく変えすぎると、急に成績が落ちて戻らなくなることがあります。2017 年に OpenAI が発表した PPO（Proximal Policy Optimization）は、更新の前後での行動の確率の比 ratio（新しい方策での確率 ÷ 古い方策での確率）が 1 から離れすぎないように、目的の関数を クリップ（切り詰め）します。

行動の良さ（advantage：その行動が平均よりどれだけ良かったか）が +1 と −1 の場合に、確率の比を変えて目的の関数の値を計算してみます。

import numpy as np

def ppo_objective(ratio, advantage, clip=0.2):
    return np.minimum(ratio * advantage, np.clip(ratio, 1 - clip, 1 + clip) * advantage)

for ratio in [0.5, 0.9, 1.0, 1.1, 1.5, 3.0]:
    print(ratio, round(float(ppo_objective(ratio, 1.0)), 2), round(float(ppo_objective(ratio, -1.0)), 2))

実行結果:

0.5 0.5 -0.8
0.9 0.9 -0.9
1.0 1.0 -1.0
1.1 1.1 -1.1
1.5 1.2 -1.5
3.0 1.2 -3.0

中央の列（良かった行動）を見ると、確率を 1.2 倍より大きく上げても目的の関数は 1.2 で頭打ちになります。右の列（悪かった行動）では、確率を 0.8 倍より小さく下げても −0.8 から良くなりません。これ以上変えても得をしないので、1 回の更新では方策が古い方策の近くにとどまります。一方で、良かった行動の確率を下げる・悪かった行動の確率を上げる向きの変化（右の列の 1.5 や 3.0）は、そのまま損として残ります。

PPO は実装が簡単で安定しているので、ロボットの制御やゲームから、後で説明する ChatGPT の RLHF まで、広く使われています。

AlphaGo：探索と学習を組み合わせる

モンテカルロ木探索

囲碁は打てる手の数がとても多く、チェスや将棋のように先の手を全部読んで評価する方法がうまくいきませんでした。そこで使われるようになったのが モンテカルロ木探索（MCTS）です。ある局面から最後までランダムに打つ（プレイアウト）ことを何千回もくり返し、勝率の高い手を選びます。

どの手を多く試すかは、スロットマシンと同じ「探索と活用」の問題です。代表的な UCT では、「勝率 + 試した回数が少ないほど大きくなるおまけ」が最大の手を選びます。

import math

def ucb(wins, visits, parent_visits, c=1.4):
    return wins / visits + c * math.sqrt(math.log(parent_visits) / visits)

# 親の局面から 100 回試した。手 A は 60 回試して 36 勝、手 B は 10 回試して 5 勝、手 C は 30 回試して 15 勝
for name, w, n in [("A", 36, 60), ("B", 5, 10), ("C", 15, 30)]:
    print(name, round(w / n, 3), round(ucb(w, n, 100), 3))

実行結果:

A 0.6 0.988
B 0.5 1.45
C 0.5 1.049

勝率だけなら A（0.6）がいちばんですが、次に試すのは、まだ 10 回しか試していない B（1.45）です。B と C は勝率が同じでも、試した回数の少ない B のほうがおまけが大きくなります。こうして、良さそうな手を中心に、試していない手も見落とさないように探索します。

このサイトの 囲碁（9 路盤） の CPU は、このモンテカルロ木探索（UCT に RAVE という工夫を足したもの）で打っています。

AlphaGo から AlphaZero・MuZero へ

2016 年に DeepMind の AlphaGo は、世界のトップ棋士のひとりイ・セドル九段に 4 勝 1 敗で勝ちました。AlphaGo は、モンテカルロ木探索に 2 つのニューラルネットワークを組み合わせています。

ネットワーク	役割
方策ネットワーク	局面から、有望な手の確率を出す。探索する手を絞る
価値ネットワーク	局面から、勝つ見込みを出す。最後まで打たなくても局面を評価できる

AlphaGo は、まず人間の棋譜で方策ネットワークを教師あり学習し、そのあと自分どうしの対局による強化学習で強くしました。2017 年の AlphaGo Zero は人間の棋譜を使わず、自分どうしの対局だけで学んで AlphaGo を上回り、AlphaZero は同じしくみでチェス・将棋・囲碁のすべてを学びました。2020 年の MuZero は、ゲームのルールさえ教えずに、ルールのモデルまで自分で学んでいます。

RLHF：人の好みを報酬にする

大規模言語モデルを、人にとって役に立ち、安全な答え方をするように仕上げるのにも強化学習が使われています。RLHF（人間のフィードバックによる強化学習）は、次の手順で行います。

1. 同じ質問へのモデルの回答をいくつか並べ、人が良い順に並べる
2. その比べた結果から、「回答が人にどれだけ好まれるか」の点数を出す 報酬モデルを学習する
3. 言語モデルを方策、報酬モデルの点数を報酬として、PPO で言語モデルを学習する

囲碁の勝敗のような決まった報酬がない仕事でも、人の判断を報酬モデルにまとめることで強化学習を使えるようにしたのがポイントです。2022 年の InstructGPT と、それをもとにした ChatGPT はこの方法で作られました。言語モデルのしくみは アテンションと Transformer のしくみ で説明しています。

強化学習の手法の流れ

この記事で紹介した手法を年代順に並べます。研究者や企業の動きは AI 開発のキープレイヤー年表 にまとめています。

年	手法・成果	ポイント
1957	ベルマン方程式（動的計画法）	今の価値を 1 歩先の価値で表す
1988	TD 学習	1 歩先の見積もりとの差で価値を直す
1989	Q 学習	環境のしくみを知らなくても Q 値を学べる
1992	REINFORCE	方策を直接、勾配で学ぶ
1992	TD-Gammon	TD 学習とニューラルネットワークで、バックギャモンをトップレベルの強さに
1994	SARSA	次に実際に取る行動の値で Q 値を直す
2006	UCT	モンテカルロ木探索で、探索と活用のバランスを取る
2013	DQN	ゲームの画面から Q 値をニューラルネットワークで学ぶ
2016	AlphaGo	探索とニューラルネットワークを組み合わせ、トップ棋士に勝つ
2017	PPO	方策を変えすぎないようにクリップして、安定して学ぶ
2017	AlphaGo Zero・AlphaZero	人間の棋譜を使わず、自分どうしの対局だけで学ぶ
2020	MuZero	ゲームのルールのモデルまで自分で学ぶ
2022	InstructGPT・ChatGPT	人の好みを報酬にした強化学習（RLHF）で言語モデルを仕上げる

まとめ

• 強化学習は、エージェントが環境の中で行動し、もらえる報酬から良い方策を学ぶ方法で、正解のラベルを使わない
• 目標は、割引率で割り引いて足した将来の報酬の合計（収益）を最大にすること
• 今いちばん良さそうな行動ばかり取ると良い行動を見逃すので、ε-greedy などで探索と活用のバランスを取る
• 行動価値 Q はベルマン方程式を満たし、環境のしくみが分かっていれば価値反復で、分からなければ 1 歩ずつの経験から Q 学習で求められる
• Q 学習は理屈の上で最良の道を、SARSA は探索で起きる失敗も込みで安全な道を学ぶ
• 状態が多すぎるときは、DQN のようにニューラルネットワークで Q 値を表し、経験再生とターゲットネットワークで学習を安定させる
• 方策勾配法は、平均より良かった行動の確率を上げる。PPO は確率の比をクリップして、1 回の更新で方策を変えすぎないようにする
• AlphaGo はモンテカルロ木探索と方策・価値のネットワークを組み合わせ、AlphaZero は自分どうしの対局だけで学んだ
• RLHF は人の好みを報酬モデルにまとめ、PPO で言語モデルを人に好まれる答え方に仕上げる

参考

• R. S. Sutton and A. G. Barto, "Reinforcement Learning: An Introduction", 2nd ed., MIT Press 2018
• R. S. Sutton, "Learning to Predict by the Methods of Temporal Differences", Machine Learning 1988
• C. J. C. H. Watkins and P. Dayan, "Q-learning", Machine Learning 1992
• R. J. Williams, "Simple Statistical Gradient-Following Algorithms for Connectionist Reinforcement Learning", Machine Learning 1992
• G. Tesauro, "Temporal Difference Learning and TD-Gammon", Communications of the ACM 1995
• G. A. Rummery and M. Niranjan, "On-Line Q-Learning Using Connectionist Systems", Technical Report, Cambridge University 1994
• L. Kocsis and C. Szepesvári, "Bandit Based Monte-Carlo Planning", ECML 2006
• V. Mnih et al., "Playing Atari with Deep Reinforcement Learning", 2013（arXiv:1312.5602）
• V. Mnih et al., "Human-level control through deep reinforcement learning", Nature 2015
• D. Silver et al., "Mastering the game of Go with deep neural networks and tree search", Nature 2016
• J. Schulman et al., "Proximal Policy Optimization Algorithms", 2017（arXiv:1707.06347）
• D. Silver et al., "Mastering the game of Go without human knowledge", Nature 2017
• D. Silver et al., "A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play", Science 2018（arXiv:1712.01815）
• J. Schrittwieser et al., "Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model", Nature 2020（arXiv:1911.08265）
• P. Christiano et al., "Deep Reinforcement Learning from Human Preferences", NeurIPS 2017（arXiv:1706.03741）
• L. Ouyang et al., "Training language models to follow instructions with human feedback", NeurIPS 2022（arXiv:2203.02155）