Phase 09: Reinforcement Learning

Les PDM, les États, les actions et les récompenses

Type: Learn

Languages: Python

Prerequisites: Phase 1 · 06 (Probability & Distributions), Phase 2 · 01 (ML Taxonomy)

Time: ~45 minutes

Le problème

Vous écrivez un robot d'échecs, un planificateur d'inventaire, un agent de trading, ou la boucle PPO qui entraîne un modèle de raisonnement, quatre domaines différents, un fait surprenant: les quatre s'effondrent dans le même objet mathématique.

L' apprentissage supervisé vous donne (x, y)L'apprentissage de renforcement ne vous donne pas d'étiquettes, seulement un flux d'états, les actions que vous avez prises et une récompense scalaire. La décision de réapprovisionnement a-t-elle économisé de l'argent? le commerce a-t-il fait un profit? le jeton que le LLM vient de produire a-t-il conduit à une récompense plus élevée du juge?

Vous ne pouvez pas apprendre de ce flux avant de le formaliser. "Ce que j'ai vu," "ce que j'ai fait," "ce qui s'est passé ensuite," "combien cela a été bon" chacun doit devenir un objet que vous pouvez raisonner à propos. Cette formalisation est un processus de décision Markov. Tout algorithme RL dans cette phase, y compris les boucles RLHF et GRPO à la fin, optimise sur cette forme.

Le concept

!Markov decision process: states, actions, transitions, rewards, discount

The five objects.

• States SDans GridWorld, la cellule, dans les échecs, le tableau, dans un LLM, la fenêtre contextuelle et toute mémoire.
• Actions ALes choix, monter/baisser/gauche/droite, jouer un mouvement, émettre un jeton.
• Transitions P(s' | s, a)- Dans l' état actuel .set action aDéterministique dans les échecs, stochastique dans l'inventaire, presque déterministe dans le décoding LLM.
• Rewards R(s, a, s')Le signal scalaire. Le gain = +1, la perte = -1. Retour moins coût.
• Discount γ ∈ [0, 1)- Combien compte la récompense future par rapport au présent ?γ = 0.99achète un horizon de ~ 100 étapes; γ = 0.9Il achète 10 $.

The Markov property P(s_{t+1} | s_t, a_t) = P(s_{t+1} | s_0, a_0, …, s_t, a_t)L'avenir ne dépend que de l'état actuel. Si ce n'est pas le cas, la représentation de l'État est incomplète.

Policies and returns.Une politiqueπ(a | s)Les cartes indiquent les répartitions d'action.G_t = r_t + γ r_{t+1} + γ² r_{t+2} + …est la somme réduite des récompenses futures.V^π(s) = E[G_t | s_t = s]est le rendement attendu à partir de sdans le cadre de la politique πLa valeur QQ^π(s, a) = E[G_t | s_t = s, a_t = a]L'algorithme RL évalue l'un de ces deux, puis l'améliore πEn conséquence.

The Bellman equations.Les équations à point fixe que tout utilise dans cette phase:

V^π(s) = Σ_a π(a|s) Σ_{s', r} P(s', r | s, a) [r + γ V^π(s')]

Q^π(s, a) = Σ_{s', r} P(s', r | s, a) [r + γ Σ_{a'} π(a'|s') Q^π(s', a')]

Ces fractions attendues reviennent en "récompense de cette étape" plus "valeur réduite de l'endroit où vous atterrissez". Récursif. Chaque algorithme de la phase 9 réitère soit cette équation à la convergence (programme dynamique), des échantillons de celle-ci (Monte Carlo), soit le démarre à un pas (différence temporelle).

Faites-le

Étape 1: un petit MDP déterministe

Un 4x4 GridWorld. L'agent commence en haut à gauche, le terminal en bas à droite, récompense de -1 par étape, actions.{up, down, left, right}- Vous voyez ?code/main.py- Je suis désolé .

pythonCopyGRID = 4
TERMINAL = (3, 3)
ACTIONS = {"up": (-1, 0), "down": (1, 0), "left": (0, -1), "right": (0, 1)}

def step(state, action):
    if state == TERMINAL:
        return state, 0.0, True
    dr, dc = ACTIONS[action]
    r, c = state
    nr = min(max(r + dr, 0), GRID - 1)
    nc = min(max(c + dc, 0), GRID - 1)
    return (nr, nc), -1.0, (nr, nc) == TERMINAL

Cinq lignes, c'est l'environnement entier, des transitions déterministes, une pénalité constante, un état terminal absorbant.

Étape 2: mise en place d'une politique

Une politique est une fonction de la répartition de l'état à l'action.

pythonCopydef uniform_policy(state):
    return {a: 0.25 for a in ACTIONS}

def rollout(policy, max_steps=200):
    s, total, steps = (0, 0), 0.0, 0
    for _ in range(max_steps):
        a = sample(policy(s))
        s, r, done = step(s, a)
        total += r
        steps += 1
        if done:
            break
    return total, steps

Exécutez la politique aléatoire 1000 fois. Le retour moyen est d'environ -60 à -80 pour cette carte 4x4. Le retour optimal est -6 (route droite vers le bas). Fermer cet écart est tout dans la phase 9.

Étape 3: calculerV^πexactement par l'équation de Bellman

Pour les petites MDP, l'équation de Bellman est un système linéaire.

pythonCopydef policy_evaluation(policy, gamma=0.99, tol=1e-6):
    V = {s: 0.0 for s in all_states()}
    while True:
        delta = 0.0
        for s in all_states():
            if s == TERMINAL:
                continue
            v = 0.0
            for a, pi_a in policy(s).items():
                s_next, r, _ = step(s, a)
                v += pi_a * (r + gamma * V[s_next])
            delta = max(delta, abs(v - V[s]))
            V[s] = v
        if delta < tol:
            return V

Il s'agit d'une évaluation de politique itérative. C'est le premier algorithme de Sutton & Barto et la base théorique de chaque méthode RL qui suit.

Étape 4:γest un hyperparamètre ayant une signification physique

L' horizon effectif est approximatif 1 / (1 - γ)- Je suis là .γ = 0.9→ 10 étapes. γ = 0.99→ 100 pas. γ = 0.999→ 1000 pas.

La récompense est trop faible et l'agent agit de manière myope.γ = 1Les tâches de contrôle utilisent des techniques de contrôle.0.95–0.99. Jeux de stratégie à long horizon utilisent 0.999- Je suis désolé .

Les pièges

• Non-Markovian state.Si vous avez besoin des trois dernières observations pour décider, l'"état" n'est pas seulement l'observation actuelle.
• Sparse rewards.Les récompenses uniquement gagnantes rendent l'apprentissage presque impossible dans de grands espaces d'état.
• Reward hacking.L'optimisation d'une récompense par procuration produit souvent un comportement pathologique. L'agent de course à la barque d'OpenAI tourne en cercles collectant des powerups pour toujours au lieu de terminer la course. Définissez toujours la récompense à partir du résultat cible, pas le procuration.
• Discount mis-spec. γ = 1Dans une tâche à horizon infini, chaque valeur est infinie.γ < 1- Je suis désolé .
• Reward scale.Les récompenses de {+100, -100} par rapport à {+1, -1} donnent des politiques optimales identiques mais des magnitudes de gradient très différentes.[-1, 1]- avant de se connecter au PPO/DQN.

Utilisez-le

La pile 2026 réduit chaque pipeline RL à un MDP avant de toucher le code:

Écrivez les cinq tuples avant d'écrire une boucle d'entraînement.

La faire partir

• Je ne sais pas .outputs/skill-mdp-modeler.md- Le numéro de la liste:

markdownCopy---
name: mdp-modeler
description: Given a task description, produce a Markov Decision Process spec and flag formulation risks before training.
version: 1.0.0
phase: 9
lesson: 1
tags: [rl, mdp, modeling]
---

Given a task (control / game / recommendation / LLM fine-tuning), output:

1. State. Exact feature vector or tensor spec. Justify Markov property.
2. Action. Discrete set or continuous range. Dimensionality.
3. Transition. Deterministic, stochastic-with-known-model, or sample-only.
4. Reward. Function and source. Sparse vs shaped. Terminal vs per-step.
5. Discount. Value and horizon justification.

Refuse to ship any MDP where the state is non-Markovian without explicit mention of frame-stacking or recurrent state. Refuse any reward that was not defined in terms of the target outcome. Flag any `γ ≥ 1.0` on an infinite-horizon task. Flag any reward range >100x the typical step reward as a likely gradient-explosion source.

Exercices

1. Easy.Mettre en œuvre le 4×4 GridWorld et le déploiement de la politique aléatoire en code/main.py- 10 000 épisodes, rapportez le rapport moyen et le rapport de rendement, comparez le rapport optimal (-6).
2. Medium.On court .policy_evaluationavec γ ∈ {0.5, 0.9, 0.99}Pour la politique uniforme et aléatoire.VExpliquez pourquoi les valeurs d'état près du terminal augmentent plus rapidement avec la plus grande.γ- Je suis désolé .
3. Hard.Tournez le GridWorld stochastique: chaque action glît dans une direction adjacente avec probabilité p = 0.1- Réévaluer la politique uniforme.V[start]- Ça va s'améliorer ou empirer ?

Les termes clés

Pour en savoir plus

• Sutton & Barto (2018). Reinforcement Learning: An Introduction, 2nd ed.Le chapitre 3 couvre les équations MDP et Bellman; le chapitre 1 motive l'hypothèse de récompense qui sous-tend chaque leçon ultérieure.
• Bellman (1957). Dynamic Programming l'origine de l'équation de Bellman.
• OpenAI Spinning Up — Part 1: Key Concepts Primer concis MDP sous un angle de RL profond.
• Puterman (2005). Markov Decision Processes la référence de recherche opérationnelle sur les PDM et les méthodes de solution exactes.
• Littman (1996). Algorithms for Sequential Decision Making (PhD thesis) la dérivation la plus nette des PDM en tant que spécialisation de la programmation dynamique.

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.