Phase 09: Reinforcement Learning

Dinamik Programlama Politika İterasyonu & Değer İterasyonu

Dinamik programlama, aldatmacılık ile RL'dir.Vveya πBu, her örnekleme tabanlı yöntemin yaklaşmaya çalıştığı referans değeridir.

Type: Build

Languages: Python

Prerequisites: Phase 9 · 01 (MDPs)

Time: ~75 minutes

Sorun

Bilinen bir modelle bir MDP 'ye sahipsiniz: sorguya girebilirsiniz P(s' | s, a)ve R(s, a, s')Bu, bir envanter yöneticisi olarak talep dağılımını bilir. bir masa oyunu belirlenmiş geçişler vardır. bir gridworld Python'un dört satırı.

Modelsiz RL (Q-learning, PPO, REINFORCE) bir modeliniz olmadığı durum için icat edildi. Sadece çevreye örnek alabilirsiniz. Ama bir tane olduğunda, daha hızlı, daha iyi yöntemler vardır: dinamik programlama. Bellman onları 1957'de tasarladı.

2026'da üç nedenden dolayı ihtiyaç duyarsınız. Birincisi, RL araştırmalarında her tablo ortamı (GridWorld, FrozenLake, CliffWalking) altın standart politikasını üretmek için DP ile çözülür.V*(s_0)Üçüncü olarak, modern çevrimdışı RL ve planlama yöntemleri (MCTS, AlphaZero'nun arama, 9. · 10 aşamada model tabanlı RL) hepsi Bellman yedeklemeyi öğrenilen veya verilen bir model üzerinde tekrarlar.

Anlaşım

!Policy iteration and value iteration, side by side

Two algorithms, both fixed-point iteration on Bellman.

Policy iteration.Politika değişmezken iki adım değiştiriyor.

Değerlendirme: belirli politika π, hesaplamaV^πTekrar tekrar uygulayarak V(s) ← Σ_a π(a|s) Σ_{s',r} P(s',r|s,a) [r + γ V(s')]Bir araya gelene kadar.
Yenileştirme: verildi V^π, yapınπAçgözlü bir hırsızlık .V^π- Evet .π(s) ← argmax_a Σ_{s',r} P(s',r|s,a) [r + γ V(s')]- Evet .

Dönüşüm garanti edilir çünkü (a) her iyileştirme aşamasında ya πAynı veya sıkı bir şekilde artıyor V^πBazı devletler için (b) belirleyici politikaların alanı sınırlıdır. Genellikle büyük devlet alanları için bile ~520 dış iterasyonlarda birleşti.

Value iteration.Değerlendirme ve iyileştirme bir süpürgeye çöküyor. Bellman optimizasyon denklemini uygulayın:

V(s) ← max_a Σ_{s',r} P(s',r|s,a) [r + γ V(s')]

max_s |V_{new}(s) - V(s)| < ε. Açgözlü eylemleri yaparak son politika çıkar. Yeterlikçe daha hızlı iç değerlendirme döngüsü ama genellikle daha fazla iterasyon konverje gerekir.

Generalized policy iteration (GPI).Birleştiren çerçeveleme. Değer fonksiyonu ve politika iki yönlü bir geliştirme döngüsünde kilitlenir; her iki yönü de karşılıklı tutarlılığa (asynk değer iterasyonu, değiştirilmiş politika iterasyonu, Q-öğrenme, aktör eleştirmeni, PPO) yönlendiren herhangi bir yöntem GPI'nin bir örneğidir.

Why γ < 1 matters.Bellman operatörü bir γ-Sup-norm'daki kısıtlama: ||T V - T V'||_∞ ≤ γ ||V - V'||_∞-Kısıtlama, benzersiz sabit nokta ve geometrik bir yakınlık anlamına gelir.γ < 1Ve garantiyi kaybedersen... ...bir sınırlı ufaklık veya absorber bir terminal durum gerekir.

Yapın

Adım 1: GridWorld MDP modeli oluştur

Ders 1'den aynı 4×4 GridWorld'u kullanın.0.1ajan rastgele dik yönde kayar.

pythonSLIP = 0.1

def transitions(state, action):
    if state == TERMINAL:
        return [(state, 0.0, 1.0)]
    outcomes = []
    for direction, prob in action_probs(action):
        outcomes.append((apply_move(state, direction), -1.0, prob))
    return outcomes

transitions(s, a) listesi gönderir(s', r, p)Bu tüm model.

Adım 2: Politika değerlendirme

Bir politika göre .π(s) = {action: prob}, Bellman denklemini tekrarlayalım .Vhareket etmeyi durdurur:

pythondef policy_evaluation(policy, gamma=0.99, tol=1e-6):
    V = {s: 0.0 for s in states()}
    while True:
        delta = 0.0
        for s in states():
            v = sum(pi_a * sum(p * (r + gamma * V[s_prime])
                              for s_prime, r, p in transitions(s, a))
                   for a, pi_a in policy(s).items())
            delta = max(delta, abs(v - V[s]))
            V[s] = v
        if delta < tol:
            return V

Adım 3: Politikayı iyileştirmek

Değiştir πAçgözlü politika ile.V- Eğer ...πDeğişmemiş, geri dönmüş en iyisindeyiz.

pythondef policy_improvement(V, gamma=0.99):
    new_policy = {}
    for s in states():
        best_a = max(
            ACTIONS,
            key=lambda a: sum(p * (r + gamma * V[s_prime])
                              for s_prime, r, p in transitions(s, a)),
        )
        new_policy[s] = best_a
    return new_policy

Dördüncü adım: Bir araya getirin

pythondef policy_iteration(gamma=0.99):
    policy = {s: "up" for s in states()}   # arbitrary start
    for _ in range(100):
        V = policy_evaluation(lambda s: {policy[s]: 1.0}, gamma)
        new_policy = policy_improvement(V, gamma)
        if new_policy == policy:
            return V, policy
        policy = new_policy

4×4: 46 dış iterasyonlarında tipik bir yakınlık.V*(0,0) ≈ -6Ve adım sayısını kesinlikle azaltan bir politika.

Adım 5: değer iterasyonu (bir döngü versiyonu)

pythondef value_iteration(gamma=0.99, tol=1e-6):
    V = {s: 0.0 for s in states()}
    while True:
        delta = 0.0
        for s in states():
            v = max(sum(p * (r + gamma * V[s_prime])
                       for s_prime, r, p in transitions(s, a))
                   for a in ACTIONS)
            delta = max(delta, abs(v - V[s]))
            V[s] = v
        if delta < tol:
            break
    policy = policy_improvement(V, gamma)
    return V, policy

Aynı sabit nokta, daha az kod satırı.

Tuzaklar

Forgetting to handle terminals.Bellman'ı emekçi bir duruma uyguladığınızda, hiçbir şey değiştirmeyen "en iyi eylem" alır.if s == terminal: V[s] = 0- Evet .
Sup-norm vs L2 convergence.Kullanımmax |V_new - V|Teorik garanti sup-norma üzerinde.
In-place vs synchronous updates.GüncellemeV[s]Yerde (Gauss-Seidel) ayrı bir V_newÜretim kodu yerinde kullanılıyor.
Policy ties.Eğer iki işlem aynı Q değeri varsa,argmaxHer iterasyonda farklı şekilde bağları kırmak, "politik istikrarlı" kontrolünün oscilansına neden olabilir.
State-space explosion.DP O(|S| · |A|)Bu işlemler, 107. durumlara kadar çalışmaktadır.

Kullan

2026 yılında DP, planlamacıların doğruluk başlangıç çizgisi ve iç döngüsüdür:

Use case	Method
Solve a small tabular MDP exactly	Value iteration (simpler) or policy iteration (fewer outer steps)
Verify a Q-learning / PPO implementation	Compare to DP-optimal V* on a toy environment
Model-based RL (Phase 9 · 10)	Bellman backup on a learned transition model
Planning in AlphaZero / MuZero	Monte Carlo Tree Search = async Bellman backup
Offline RL (CQL, IQL)	Conservative Q-iteration — DP with a penalty on OOD actions

Birisi "optimal değer fonksiyonu" dediğinde, "DP sabit noktası" demek istiyorlar.Vveya QBir kağıtda, bu döngüyü hayal edin.

Gönder

Kaydet .outputs/skill-dp-solver.md- ...

markdown---
name: dp-solver
description: Solve a small tabular MDP exactly via policy iteration or value iteration. Report convergence behavior.
version: 1.0.0
phase: 9
lesson: 2
tags: [rl, dynamic-programming, bellman]
---

Given an MDP with a known model, output:

1. Choice. Policy iteration vs value iteration. Reason tied to |S|, |A|, γ.
2. Initialization. V_0, starting policy. Convergence sensitivity.
3. Stopping. Sup-norm tolerance ε. Expected number of sweeps.
4. Verification. V*(s_0) computed exactly. Greedy policy extracted.
5. Use. How this baseline will be used to debug/evaluate sampling-based methods.

Refuse to run DP on state spaces > 10⁷. Refuse to claim convergence without a sup-norm check. Flag any γ ≥ 1 on an infinite-horizon task as a guarantee violation.

Egzersizler

Easy.4×4 GridWorld'de değer iterasyonunu ile çalıştırγ ∈ {0.9, 0.99}- Ne kadar süpürür ?max |ΔV| < 1e-6- BaskıV*4×4 şebekesi olarak.
Medium. Stochastic GridWorld'de politika iterasyonu vs değer iterasyonu karşılaştırın (slip olasılığı 0.1Sayım: süpürmeler, duvar saati, son V*(0,0)- Hangi süreler daha hızlı bir şekilde dönüşüyor?
Hard.Değiştirilmiş politika tekrarını oluştur: değerlendirme aşamasında sadece çalıştır k- Birleştirilmek yerine tarar.V*(0,0)hata vs kiçink ∈ {1, 2, 5, 10, 50}Bu eğrilik değerlendirme/iyileştirme karşılığı hakkında size ne söylüyor?

Anahtar Terimler

Term	What people say	What it actually means
Policy iteration	"DP algorithm"	Alternating evaluation (`V^π`) and improvement (greedy `π` w.r.t. `V^π`) until the policy stops changing.
Value iteration	"Faster DP"	Bellman optimality backup applied in one sweep; converges to `V*` geometrically.
Bellman operator	"The recursion"	`(T V)(s) = max_a Σ P (r + γ V(s'))`; a `γ`-contraction in sup-norm.
Contraction	"Why DP converges"	Any operator `T` with `\|\|T x - T y\|\| ≤ γ \|\|x - y\|\|` has a unique fixed point.
GPI	"Everything is DP"	Generalized Policy Iteration: any method driving `V` and `π` to mutual consistency.
Synchronous update	"Jacobi-style"	Use old `V` throughout a sweep; cleanly analyzable but slower.
In-place update	"Gauss-Seidel-style"	Use `V` as it's being updated; converges faster in practice.

Daha Fazla Okumak

Sutton & Barto (2018). Ch. 4 — Dynamic Programming politika iterasyonunun ve değer iterasyonunun kanonik sunumu.
Bertsekas (2019). Reinforcement Learning and Optimal Control Kısalaşma haritası argümanlarının sıkı şekilde ele alınması.
Puterman (2005). Markov Decision Processes modifi politikayı tekrarlama ve onun yakınlaştırma analizi.
Howard (1960). Dynamic Programming and Markov Processes orijinal politika tekrarlama kağıdı.
Bertsekas & Tsitsiklis (1996). Neuro-Dynamic Programming DP'den yaklaşık DP/ derin RL'ye kadar her sonraki dersde kullanılan köprü.

This free lesson is part of the AI Engineering from Scratch curriculum. Read the full explanation, run the lesson code, and verify the result in the interactive reader or from the repository source.

Browse the complete course catalog or open this lesson on GitHub.