Inteligencia artificial / Material de consulta

Q-learning tabular

NumPy · CPU

Consulte las explicaciones, el código y las salidas de referencia en esta página.

Especialización · Q-learning en una línea

Overtone Education · Curso de inteligencia artificial

Objetivo

Entrenar una política tabular en cinco estados sintéticos. Distinguir exploración, recompensa de entrenamiento y evaluación greedy separada. Corre en CPU, sin entorno remoto.

Preparación

Ejecute de arriba abajo en Jupyter con Python 3.12 (entorno validado). Entorno externo al aula. Instale en un entorno virtual:

python -m pip install numpy ipykernel

Las versiones comprobadas se distribuyen en requirements-ia.txt. No necesita claves de API. Los ejemplos son educativos y no validan aplicaciones de impacto alto.

Pasos

1. Definir estados, acciones y transiciones

Estados 0 a 4; 4 es terminal. Acción 0: izquierda, acción 1: derecha. Llegar al objetivo da +1 y cada paso no terminal cuesta -0.02. Un límite de pasos evita bucles sin fin.

Código de referencia

import numpy as np
rng = np.random.default_rng(7)
Q = np.zeros((5,2))
alpha,gamma,epsilon = .2,.95,.2
def transicion(estado,accion):
    siguiente = max(0,min(4,estado+(-1 if accion==0 else 1)))
    terminal = siguiente==4
    recompensa = 1.0 if terminal else -.02
    return siguiente,recompensa,terminal

2. Entrenar con exploración

El objetivo terminal solo contiene recompensa; los otros pasos incluyen la mejor estimación del siguiente estado. La semilla hace reproducible esta demostración, pero no reemplaza repetir experimentos.

Código de referencia

for episodio in range(400):
    estado = 0
    for paso in range(30):
        if rng.random()<epsilon:
            accion = int(rng.integers(2))
        else:
            empates = np.flatnonzero(Q[estado]==Q[estado].max())
            accion = int(rng.choice(empates))
        siguiente,recompensa,terminal = transicion(estado,accion)
        objetivo = recompensa if terminal else recompensa+gamma*Q[siguiente].max()
        Q[estado,accion] += alpha*(objetivo-Q[estado,accion])
        estado = siguiente
        if terminal:
            break
print("Q (columnas izquierda/derecha):")
print(np.round(Q,3))

Salida comprobada

Q (columnas izquierda/derecha):
[[0.74  0.8  ]
 [0.74  0.863]
 [0.8   0.93 ]
 [0.863 1.   ]
 [0.    0.   ]]

3. Evaluar sin explorar

La política greedy se evalúa después de entrenar. No actualiza Q durante este recorrido. Se mide si alcanza el objetivo y cuántos pasos utiliza.

Código de referencia

estado = 0
ruta = [estado]
retorno = 0.0
for paso in range(30):
    accion = int(Q[estado].argmax())
    estado,recompensa,terminal = transicion(estado,accion)
    ruta.append(estado)
    retorno += recompensa
    if terminal:
        break
print({"ruta":ruta,"retorno_sin_descuento":round(retorno,3)})

Salida comprobada

{'ruta': [0, 1, 2, 3, 4], 'retorno_sin_descuento': 0.94}

Comprobaciones

El ejemplo debería aprender cuatro movimientos a la derecha. Cambiar recompensa, transiciones o penalizaciones puede cambiar la política.

Código de referencia

assert ruta==[0,1,2,3,4]
assert np.isfinite(Q).all()
assert np.all(Q[:4].argmax(axis=1)==1)
print("Comprobaciones aprobadas")

Salida comprobada

Comprobaciones aprobadas

Siguientes pasos

Añada transiciones estocásticas y repita con varias semillas.
Compare epsilon fijo frente a uno decreciente.
Diseñe una recompensa que el agente pueda explotar y explique el fallo.
Para DQN necesitará aproximación neuronal, replay y red objetivo; este notebook no los implementa.

Referencia: https://cs50.harvard.edu/ai/