Marco básico del aprendizaje por refuerzo

Imagina que le estás enseñando a un cachorro la orden de “sentarse”. No le dices directamente cómo debe mover cada músculo para sentarse, sino que haces lo siguiente:

  1. Emites la orden de sentarse.
  2. El cachorro intenta realizar alguna acción (puede ser sentarse, echarse o girar).
  3. Si se sienta, le das inmediatamente una golosina como recompensa.
  4. Si lo hace mal, no le das recompensa o emites una leve señal de que no es correcto.
  5. Después de muchos intentos, el cachorro va comprendiendo: al oír “sentarse” y realizar la acción de sentarse, obtiene una golosina. Así aprende la orden.

El aprendizaje por refuerzoconsiste en hacer que una computadora (o agente), como este cachorro, aprenda a tomar una serie de decisiones para lograr un objetivo a largo plazo mediante la interacción con el entorno y según las recompensas o castigos obtenidos.

Es fundamentalmente diferente delaprendizaje supervisado(con un “maestro” que tiene las respuestas estándar) y delaprendizaje no supervisado(que busca la estructura interna de los datos). El aprendizaje por refuerzo esaprender de la experiencia, cuyo núcleo esel ensayo y erroryla recompensa retrasada。


Elementos centrales del aprendizaje por refuerzo

Para formalizar este proceso de aprendizaje, introducimos varios conceptos centrales que, en conjunto, constituyen el marco básico del aprendizaje por refuerzo.

Agente y entorno

Esta es la relación de interacción más básica en el aprendizaje por refuerzo.

  • Agente: Es el sujeto que aprende, la entidad que toma decisiones. En el ejemplo anterior, el cachorro es el agente. En una computadora, puede ser un algoritmo, un programa o un robot.
  • Entorno: Es el mundo exterior en el que se encuentra el agente y con el cual interactúa. Para el cachorro, el entorno eres tú, las golosinas, el suelo y todo lo externo. El entorno recibe las acciones del agente y entrega un nuevo estado y una recompensa.

Su relación es un ciclo continuo:El agente observa el entorno -> realiza una acción -> el entorno devuelve un nuevo estado y recompensa -> el agente observa de nuevo...

Estado, acción y recompensa

Estos son los tres datos clave que describen cada interacción.

  • Estado: En un momento dado, es la descripción completa de la situación del entorno. Por ejemplo, en el caso de enseñar al cachorro, el estado puede incluir: el cachorro está de pie, tienes una golosina en la mano, acabas de decir “sentarse”. El estado es la base sobre la cual el agente toma decisiones.
  • Acción: Es la elección que el agente puede tomar en un estado determinado. Para el cachorro, el conjunto de acciones podría ser {sentarse, echarse, ponerse de pie, girar...}.
  • Recompensa: Es una señal escalar que el entorno devuelve al agente después de que este ejecuta una acción. Definequé es bueno y qué es malo.La recompensa es la única brújula del aprendizaje del agente. Dar una golosina al cachorro es una recompensa positiva (+1), y decirle “no es correcto” puede considerarse una recompensa negativa leve (-0.1).

Política

PolíticaEs el cerebro o la regla de comportamiento del agente. Define qué acción debe tomar el agente en cualquier estado dado.

Una política puede ser una simple función de búsqueda en tabla o una compleja red neuronal profunda. El objetivo final del aprendizaje por refuerzo es encontrar unapolítica óptima, de modo que la recompensa acumulada a largo plazo que el agente obtiene del entornosea maximizada.。

  • Ejemplo: Una política simple podría ser: si el estado es “oír la orden de sentarse”, entonces elegir la acción de sentarse con un 90% de probabilidad y elegir otras acciones con un 10% de probabilidad.

Función de valor

La recompensa le dice al agentelo bueno o malo inmediato de laacción actual, pero el agente debe preocuparse más por elbeneficio a largoplazo.Función de valorEs la herramienta utilizada para medir ese beneficio a largo plazo.

La pregunta que responde es: desde el estado actual, siguiendo siempre una política determinada,¿cuánta recompensa total se esperapoder obtener?

  • Función de valor de estado V(s): Mide, en el estadoss, el valor a largo plazo de seguir la política actual.
  • Función de valor de acción Q(s, a): Mide, en el estadoss,después de ejecutar una acción específicaay luego seguir la política actual, el valor a largo plazo. Es más utilizada que la función de valor de estado porque puede guiar directamente la selección de acciones.

¿Por qué se necesita la función de valor?Imagina un juego de ajedrez. Comer un peón del oponente da una pequeña recompensa inmediata, pero puede llevar a que diez movimientos después te den “jaque mate” y obtengas una gran recompensa negativa. La función de valor, mediante el cálculo y la estimación, ayuda al agente a evitar ese comportamiento de dejarse llevar por la pequeña ganancia y perder la partida.


Proceso central de interacción: Proceso de Decisión de Markov

Los problemas de aprendizaje por refuerzo suelen modelarse como unProceso de Decisión de Markov. Este nombre suena complejo, pero en realidad es solo un marco estándar que organiza matemáticamente los elementos mencionados anteriormente para describir la interacción entre el agente y el entorno.

La idea central del MDP es:El siguiente estado y la recompensa dependen solo del estado actual y de la acción tomada actualmente, sin relación con el historial anterior.(es decir, la propiedad de Markov).

Un ciclo de interacción MDP completo es el siguiente:

  1. En el instante t,tel entorno se encuentra en el estado s,S_t。
  2. El agente observa este estado.
  3. El agente, según su política π,πselecciona una acción a.A_t。
  4. El entorno recibe esta acción.
  5. El entorno, de acuerdo con su dinámica interna, transita al siguiente estado s',S_{t+1}y genera una recompensa escalar r,R_{t+1}que retroalimenta al agente.
  6. El paso de tiempo avanza (t ← t+1),t = t+1y comienza un nuevo ciclo.

El objetivo del agente es, mediante la repetición continua de este ciclo, aprender una políticaπ*, tal que, comenzando desde cualquier estado inicial, laesperanza de la recompensa acumulada (es decir, el retorno) se maximice.。


Un ejemplo sencillo de código: el mundo de la cuadrícula (Grid World)

Usemos un ejemplo clásico de mundo de cuadrícula para concretar estos conceptos. Supongamos que hay una cuadrícula de 4x4; el agente parte desde el punto de inicioSy su objetivo es llegar al punto finalG. Si se encuentra con un obstáculo#falla, y cada paso tiene una pequeña penalización (para fomentar llegar lo antes posible).

S . . .
. # . .
. . # .
. . . G
  • Estado: Las coordenadas de cada celda, como (0,0), (0,1)... (3,3). Hay 16 estados en total.
  • Acción: {arriba, abajo, izquierda, derecha}.
  • Recompensa:
    • Llegar a la metaG: +10
    • Chocar con un obstáculo#o salir del límite: -5
    • Otros movimientos normales: -0.1 (fomenta rutas eficientes)
  • Política: Necesitamos aprender una tabla que registre, en cada estado (celda), hacia qué dirección se debe ir.

A continuación se muestra una demostración en pseudocódigo de Q-learning (un algoritmo clásico de aprendizaje por refuerzo) muy simplificada, para aprender la ruta óptima en este mundo de cuadrícula.

Ejemplo

import numpy as np
import random
from typing import Dict, List, Tuple

# ====================== 1. Simulación del entorno (mundo de cuadrícula) ======================
class GridWorldEnv:
    """Entorno simple de mundo de cuadrícula para demostrar Q-Learning"""
    def __init__(self, grid_size: Tuple[int, int] = (5, 5),
                 start_pos: Tuple[int, int] = (0, 0),
                 goal_pos: Tuple[int, int] = (4, 4),
                 obstacle_pos: List[Tuple[int, int]] = [(1, 1), (2, 2), (3, 1)]):
        self.grid_size = grid_size
        self.start_pos = start_pos
        self.goal_pos = goal_pos
        self.obstacle_pos = obstacle_pos
        self.current_pos = start_pos
       
        # Definición de acciones: 0-arriba, 1-abajo, 2-izquierda, 3-derecha
        self.actions = ['up', 'down', 'left', 'right']
        self.num_actions = len(self.actions)
       
    def reset(self) -> int:
        """Reinicia el entorno y devuelve el índice del estado inicial"""
        self.current_pos = self.start_pos
        return self.pos_to_state(self.current_pos)
   
    def pos_to_state(self, pos: Tuple[int, int]) -> int:
        """Convierte la posición de coordenadas al índice de estado"""
        return pos[0] * self.grid_size[1] + pos[1]
   
    def state_to_pos(self, state: int) -> Tuple[int, int]:
        """Convierte el índice de estado a la posición de coordenadas"""
        return (state // self.grid_size[1], state % self.grid_size[1])
   
    def random_action(self) -> int:
        """Selecciona una acción aleatoria (exploración)"""
        return random.randint(0, self.num_actions - 1)
   
    def action_to_direction(self, action: int) -> str:
        """Convierte el índice de acción al nombre de la dirección"""
        return self.actions[action]
   
    def step(self, action: int) -> Tuple[int, float, bool]:
        """
Ejecuta la acción y devuelve (next_state, reward, done)
Punto de optimización: corregir el bug de que la recompensa por obstáculo no se activaba; simplificar la lógica de decisión.
        """

        x, y = self.current_pos
       
        # Actualiza la posición según la acción
        if action == 0:  # Arriba
            x = max(0, x - 1)
        elif action == 1:  # Abajo
            x = min(self.grid_size[0] - 1, x + 1)
        elif action == 2:  # Izquierda
            y = max(0, y - 1)
        elif action == 3:  # Derecha
            y = min(self.grid_size[1] - 1, y + 1)
       
        # Comprueba si se ha chocado con un obstáculo (arreglo central: registrar primero si se ha chocado y luego procesar la posición)
        new_pos = (x, y)
        hit_obstacle = False  # Marca si se ha chocado con un obstáculo
        if new_pos in self.obstacle_pos:
            hit_obstacle = True  # Registra el estado de colisión con obstáculo
            new_pos = self.current_pos  # Si se choca con un obstáculo, la posición no cambia
       
        self.current_pos = new_pos
        next_state = self.pos_to_state(new_pos)
       
        # Calcula la recompensa (basada en hit_obstacle registrado previamente; corrige la contradicción lógica original)
        if new_pos == self.goal_pos:
            reward = 100.0  # Llegar a la meta, gran recompensa
            done = True
        elif hit_obstacle:  # Juicio basado en la marca, no en el new_pos modificado
            reward = -50.0  # Chocar con obstáculo, penalización
            done = False
        else:
            reward = -1.0  # Pequeña penalización por cada paso, anima a llegar a la meta lo antes posible
            done = False
       
        return next_state, reward, done

# ====================== 2. Programa principal de Q-Learning ======================
if __name__ == "__main__":
    # Punto de optimización 1: fijar la semilla aleatoria para garantizar la reproducibilidad de los resultados experimentales
    random_seed = 42
    random.seed(random_seed)
    np.random.seed(random_seed)
   
    # Inicializar el entorno
    env = GridWorldEnv(
        grid_size=(5, 5),          # Cuadrícula de 5x5
        start_pos=(0, 0),          # Punto de inicio
        goal_pos=(4, 4),           # Punto de meta
        obstacle_pos=[(1,1), (2,2), (3,1)]  # Posición de los obstáculos
    )
   
    # Calcular el número de estados
    num_states = env.grid_size[0] * env.grid_size[1]
    num_actions = env.num_actions
   
    # Inicializar la tabla Q (función de valor de acción), con forma [número de estados, número de acciones]
    Q_table = np.zeros([num_states, num_actions])
   
    # Definir hiperparámetros
    learning_rate = 0.1       # Tasa de aprendizaje
    discount_factor = 0.9     # Factor de descuento
    epsilon = 0.1             # Tasa de exploración
    total_episodes = 1000     # Número de épocas de entrenamiento
   
    # Proceso de entrenamiento
    for episode in range(total_episodes):
        state = env.reset()    # Reiniciar el entorno al punto de inicio, obtener el estado inicial S
        done = False           # Marcar si el episodio actual ha terminado
        total_reward = 0       # Registrar la recompensa total del episodio actual
       
        while not done:
            # 1. Selección de acción con política ε-greedy
            if random.uniform(0, 1) < epsilon:
                action = env.random_action()  # Exploración: seleccionar acción aleatoria
            else:
                # Explotación: seleccionar la acción con mayor valor Q, manejar empates
                q_values = Q_table[state]
                max_q = np.max(q_values)
                best_actions = np.where(q_values == max_q)[0]
                action = random.choice(best_actions)  # En caso de empate, seleccionar uno aleatoriamente
           
            # 2. Ejecutar la acción e interactuar con el entorno
            next_state, reward, done = env.step(action)
            total_reward += reward
           
            # 3. Actualizar la tabla Q (núcleo: fórmula de Q-Learning)
            # Q(S, A) = Q(S, A) + α * [ R + γ * max(Q(S', a')) - Q(S, A) ]
            old_value = Q_table[state, action]
            next_max = np.max(Q_table[next_state])  # Valor Q máximo del siguiente estado
           
            # Calcular el valor Q objetivo
            target = reward + discount_factor * next_max
            # Actualizar el valor Q
            new_value = old_value + learning_rate * (target - old_value)
            Q_table[state, action] = new_value
           
            # 4. Pasar al siguiente estado
            state = next_state
       
        # Imprimir el progreso del entrenamiento cada 100 episodios
        if (episode + 1) % 100 == 0:
            print(f"Episode {episode + 1}/{total_episodes}, Total Reward: {total_reward:.1f}")
   
    # ====================== 3. Extraer la política óptima (optimizar el formato de impresión, más intuitivo) ======================
    policy: Dict[int, str] = {}
    print("\n=== Política óptima tras el aprendizaje (dispuesta en cuadrícula) ===")
   
    # Punto de optimización 2: imprimir en forma de cuadrícula para mostrar intuitivamente la política de toda la cuadrícula
    grid_rows, grid_cols = env.grid_size
    for row in range(grid_rows):
        row_str = []
        for col in range(grid_cols):
            pos = (row, col)
            state = env.pos_to_state(pos)
            if pos in env.obstacle_pos:
                row_str.append(" Obstáculo ")
            elif pos == env.goal_pos:
                row_str.append(" Meta ")
            elif pos == env.start_pos:
                # Marcar también el punto de inicio y su acción óptima
                best_action_idx = np.argmax(Q_table[state])
                best_action = env.action_to_direction(best_action_idx)
                row_str.append(f" Inicio({best_action}) ")
            else:
                best_action_idx = np.argmax(Q_table[state])
                best_action = env.action_to_direction(best_action_idx)
                policy[state] = best_action
                row_str.append(f"   {best_action}   ")
        print("|".join(row_str))
   
    # ====================== 4. Probar la política óptima ======================
    print("\n=== Probar la política óptima ===")
    state = env.reset()
    done = False
    steps = 0
    path = [env.state_to_pos(state)]
   
    while not done and steps < 50:  # Máximo 50 pasos para evitar bucles infinitos
        best_action_idx = np.argmax(Q_table[state])
        next_state, reward, done = env.step(best_action_idx)
        current_pos = env.state_to_pos(next_state)
        path.append(current_pos)
        state = next_state
        steps += 1
   
    print(f"Ruta: {path}")
    print(f"Pasos para llegar a la meta: {steps}")
    print(f"¿Llegó a la meta?: {env.current_pos == env.goal_pos}")

Análisis del código:

  • Q_tablees la función de valor de acción central, con forma de[número de estados, número de acciones](en el ejemplo es 25×4, correspondiente a los 25 estados de la cuadrícula de 5×5 y las 4 acciones: arriba, abajo, izquierda, derecha).Q_table[s, a]representa en el estados(índice de la posición en la cuadrícula) ejecutar la accióna(0-3 corresponden a arriba, abajo, izquierda, derecha) el valor a largo plazo, inicialmente todos en 0, se actualizan gradualmente mediante el entrenamiento.
  • env.step(action)Simula la lógica de interacción central del Proceso de Decisión de Markov (MDP): tras introducir el índice de acción, primero actualiza la posición del agente en la cuadrícula (si choca con un obstáculo, la posición no cambia), y luego devuelve una tupla de tres elementos(next_state, reward, done)——next_statees el índice del nuevo estado,rewardes la recompensa diferenciada (meta +100, obstáculo -50, cada paso -1),donemarca si se ha llegado a la meta (fin del episodio actual).
  • La fórmula central de actualización de Q-LearningQ(S,A) = Q(S,A) + α * [R + γ * max(Q(S', a')) - Q(S,A)]se implementa desglosada en el código: primero se obtiene el valor Q actualold_value, luego se calcula el valor Q máximo del siguiente estadonext_max, después se calcula el valor objetivotarget = 奖励 + 折扣因子 × 下一状态最大Q值, y finalmente con la tasa de aprendizajeαse combinan el valor anterior y el valor objetivo para obtener el valor Q actualizado, logrando la corrección iterativa del valor de las acciones.
  • epsilon(tasa de exploración) equilibra "explotación" y "exploración" mediante la política ε-greedy: con probabilidadepsilonseleccionar una acción aleatoria (explorar lo desconocido), con probabilidad1-epsilonseleccionar la acción con mayor valor Q en el estado actual (explotar el óptimo conocido); el código también optimiza el caso de empate en valores Q: si varias acciones tienen el mismo valor Q, se elige una aleatoriamente para evitar la rigidez de la política causada por una selección única.
  • El código además implementa el mapeo bidireccional entre estados y posiciones de la cuadrícula (pos_to_state/state_to_pos), la conversión entre acciones y nombres de direcciones (action_to_direction), así como la extracción y prueba de la política tras el entrenamiento: recorrer todos los estados, tomar la acción con mayor valor Q en cada estado como política óptima, y verificar la ruta y los pasos de dicha política desde el inicio hasta la meta.
Salida:
Episode 100/1000, Total Reward: 93.0
Episode 200/1000, Total Reward: 90.0
Episode 300/1000, Total Reward: 92.0
Episode 400/1000, Total Reward: 90.0
Episode 500/1000, Total Reward: 93.0
Episode 600/1000, Total Reward: 93.0
Episode 700/1000, Total Reward: 91.0
Episode 800/1000, Total Reward: 93.0
Episode 900/1000, Total Reward: 93.0
Episode 1000/1000, Total Reward: 93.0

=== 学习完成后的最优策略 ===
位置 (0, 0): 最优动作 = right
位置 (0, 1): 最优动作 = right
位置 (0, 2): 最优动作 = down
位置 (0, 3): 最优动作 = down
位置 (0, 4): 最优动作 = down
位置 (1, 0): 最优动作 = up
位置 (1, 1): 最优动作 = 障碍物
位置 (1, 2): 最优动作 = right
位置 (1, 3): 最优动作 = down
位置 (1, 4): 最优动作 = left
位置 (2, 0): 最优动作 = down
位置 (2, 1): 最优动作 = down
位置 (2, 2): 最优动作 = 障碍物
位置 (2, 3): 最优动作 = down
位置 (2, 4): 最优动作 = down
位置 (3, 0): 最优动作 = down
位置 (3, 1): 最优动作 = 障碍物
位置 (3, 2): 最优动作 = right
位置 (3, 3): 最优动作 = right
位置 (3, 4): 最优动作 = down
位置 (4, 0): 最优动作 = right
位置 (4, 1): 最优动作 = right
位置 (4, 2): 最优动作 = right
位置 (4, 3): 最优动作 = right
位置 (4, 4): 最优动作 = 终点

=== 测试最优策略 ===
路径: [(0, 0), (0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (3, 3), (3, 4), (4, 4)]
到达终点步数: 8
是否到达终点: True

Resumen y reflexión práctica

El marco básico del aprendizaje por refuerzo se puede resumir como:El agente interactúa con el entorno mediante un proceso de decisión de Markov, y según las señales de recompensa obtenidas, optimiza continuamente su política (generalmente aprendiendo y actualizando funciones de valor), con el objetivo final de maximizar la recompensa acumulada a largo plazo.

Concepto Analogía Función en el aprendizaje por refuerzo
Agente Perrito que aprende / IA que juega al ajedrez Sujeto de decisión, ejecuta el algoritmo de aprendizaje
Entorno Entrenador / reglas del tablero Sistema externo que proporciona estados y retroalimentación de recompensas
Estado Postura del perrito / situación del tablero Base de información actual del agente para tomar decisiones
Acción Sentarse / mover una pieza Elecciones que el agente puede tomar
Recompensa Golosina / resultado de ganar o perder Señal inmediata que evalúa la calidad de las acciones, brújula del aprendizaje
Política Reacción a órdenes que el perrito ha aprendido Regla de mapeo de estados a acciones, objetivo del aprendizaje
Función de valor Juicio a largo plazo sobre la situación Evalúa el valor a largo plazo de estados o acciones, es la base de la optimización de políticas
Otras extensiones