Deep Q-Networks (DQN) en Aprendizaje por Refuerzo
¿Qué es Deep Q-Networks (DQN)?
Deep Q-Networks (DQN) es un algoritmo.
De Aprendizaje por Refuerzo Profundo
Combina Q-Learning con Redes Neuronales Profundas (DNN)
Para resolver problemas de toma de decisiones.
En entornos complejos.
De alto estado dimensional.
Fue desarrollado por DeepMind en 2015
Permite que una red neuronal.
Aprenda a jugar videojuegos de Atari desde cero
Superando a los humanos en varios juegos.
¿Cómo Funciona DQN?
DQN se basa en el algoritmo de Q-Learning
Aprende una función de valor Q (s, a)
s = Estado actual
a = Acción tomada
Q = Valor esperado de la recompensa futura
Si se toma la acción a en el estado s.
DQN reemplaza la tabla Q tradicional.
Por una Red Neuronal Profunda (DNN)
Manejar problemas con espacios.
De estado continuos o de alta dimensión.
Componentes Clave de DQN
Se usa una red neuronal para aproximar la función Q
En lugar de una tabla de valores Q.
Entrada
Estado del entorno imágenes en Atari
Coordenadas en robots, etc.
Salida
Valores Q (s, a) para cada acción posible.
Replay Memory (Memoria de Repetición)
Para evitar problemas de correlación.
En los datos de entrenamiento.
DQN almacena experiencias pasadas (s,a,r,s′s, a, r, s’)
En una memoria y entrena la red neuronal.
Muestreando aleatoriamente de este conjunto.
Beneficio
Rompe la dependencia secuencial.
Mejora la estabilidad del entrenamiento.
Target Network (Red Objetivo)
Se usa una segunda red neuronal congelada
Calcular los valores Q objetivo
Actualizándola periódicamente evitar inestabilidad.
En el entrenamiento.
La actualización de los pesos de la red objetivo
Se realiza cada N iteraciones
Minimizando el cambio abrupto.
En los valores de Q.
Algoritmo DQN Paso a Paso
Inicializar la red neuronal con pesos aleatorios.
Crear una memoria de repetición
Almacenar experiencias (s, a, r, s’)
Por cada paso en el entorno
Seleccionar una acción usando una estrategia.
ε-greedy exploración vs explotación.
Ejecutar la acción y observar la recompensa r
El nuevo estado s′
Almacenar la experiencia (s, a, r, s’)
En la memoria de repetición.
Muestrear aleatoriamente un lote de experiencias.
Para entrenar la red.
Calcular la ecuación de Bellman
Actualizar los valores Q.
Ajustar la red neuronal minimizando el error.
Actualizar la red objetivo.
Cada cierto número de pasos.
Repetir hasta que el modelo aprenda.
Una estrategia óptima.
import gym
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
import random
from collections import deque
# Crear el entorno de OpenAI Gym
env = gym.make(«CartPole-v1»)
state_size = env.observation_space.shape[0]
action_size = env.action_space.n
# Parámetros de entrenamiento
gamma = 0.95 # Factor de descuento
epsilon = 1.0 # Tasa de exploración inicial
epsilon_min = 0.01 # Límite mínimo de exploración
epsilon_decay = 0.995
learning_rate = 0.001
batch_size = 32
memory = deque(maxlen=2000)
# Definir la red neuronal de DQN
def build_model():
model = Sequential([
Dense(24, activation=»relu», input_shape=(state_size,)),
Dense(24, activation=»relu»),
Dense(action_size, activation=»linear»)
])
model.compile(loss=»mse», optimizer=Adam(learning_rate=learning_rate))
return model
# Inicializar modelo DQN
model = build_model()
# Función para tomar acción (ε-greedy)
def act(state):
global epsilon
if np.random.rand() <= epsilon:
return random.randrange(action_size) # Exploración
q_values = model.predict(state, verbose=0)
return np.argmax(q_values[0]) # Explotación
# Entrenamiento del agente
for episode in range(1000): # Entrenar por 1000 episodios
state = env.reset()[0]
state = np.reshape(state, [1, state_size])
for time in range(500): # Máximo 500 pasos por episodio
action = act(state)
next_state, reward, done, _, _ = env.step(action)
next_state = np.reshape(next_state, [1, state_size])
memory.append((state, action, reward, next_state, done))
state = next_state
# Entrenar modelo usando Replay Memory
if len(memory) > batch_size:
minibatch = random.sample(memory, batch_size)
for s, a, r, s_next, d in minibatch:
target = r
if not d:
target += gamma * np.amax(model.predict(s_next, verbose=0)[0])
target_f = model.predict(s, verbose=0)
target_f[0][a] = target
model.fit(s, target_f, epochs=1, verbose=0)
if done:
print(f»Episode {episode+1}: Score {time}»)
break
# Reducir epsilon para menor exploración
if epsilon > epsilon_min:
epsilon *= epsilon_decay
Este código implementa DQN en el juego «CartPole»
El agente debe aprender a balancear.
Un palo sobre un carrito.
Aplicaciones de DQN en el Mundo Real
Videojuegos
DQN se utilizó en Atari para aprender juegos.
Sin intervención humana.
Robótica
Permite a robots aprender tareas complejas.
Sin programación explícita.
Finanzas
Optimización de estrategias de inversión.
En mercados bursátiles.
Automóviles Autónomos
Mejora la toma de decisiones en conducción autónoma.
Ventajas y Desventajas de DQN
Ventajas
Puede manejar espacios de estado grandes y continuos.
Aprende estrategias óptimas sin conocimiento previo.
Utiliza memoria de repetición para mejorar la estabilidad.
Desventajas
Alto costo computacional y consumo de memoria.
Sensible a la selección de hiperparámetros.
Difícil de entrenar en entornos.
Extremadamente complejos.
Deep Q-Networks (DQN) permite que las máquinas aprendan.
A tomar decisiones de manera autónoma en entornos complejos.
