Implementación de 9 Algoritmos de Aprendizaje por Refuerzo Profundo con PyTorch

Este recurso presenta la implementación de nueve algoritmos de aprendizaje por refuerzo profundo (DRL) utilizando PyTorch, orientado a principiantes en el campo. Los algoritmos incluidos son REINFORCE, Actor-Critic, Rainbow-DQN, PPO-discrete, PPO-continous, DDPG, TD3, SAC y PPO-discrete-RNN.

Requisitos del Entorno

Para ejecutar las implementaciones, se requiere el siguiente entorno de software:

Python 3.7.9
NumPy 1.19.4
PyTorch 1.12.0
TensorBoard 0.6.0
Gym 0.21.0

Algoritmos Implementados

1. REINFORCE

Este método de gradiente de política utiliza muestreo de trayectorias para ajustar los parámetros de la red de política, favoreciendo acciones que conducen a recompensas más altas.

import torch
import torch.nn as nn
import gym

class NetworkPol(nn.Module):
    def __init__(self, dim_state, dim_action):
        super(NetworkPol, self).__init__()
        self.cap1 = nn.Linear(dim_state, 128)
        self.cap2 = nn.Linear(128, dim_action)

    def forward(self, entrada):
        activ = torch.relu(self.cap1(entrada))
        probabilidades = torch.softmax(self.cap2(activ), dim=1)
        return probabilidades

def ejecutar_reinforce(env, politica, optimizador, episodios, factor_descuento=0.99):
    recompensas_totales = []
    for ep in range(episodios):
        obs = env.reset()
        tensor_obs = torch.FloatTensor(obs).unsqueeze(0)
        recompensas_ep = []
        finalizado = False
        while not finalizado:
            probs = politica(tensor_obs)
            distribucion = torch.distributions.Categorical(probs)
            accion = distribucion.sample()
            nueva_obs, recompensa, finalizado, _ = env.step(accion.item())
            tensor_nueva_obs = torch.FloatTensor(nueva_obs).unsqueeze(0)
            recompensas_ep.append(recompensa)
            tensor_obs = tensor_nueva_obs
        recompensas_totales.append(sum(recompensas_ep))
        
        retornos = []
        acumulado = 0
        for r in reversed(recompensas_ep):
            acumulado = r + factor_descuento * acumulado
            retornos.insert(0, acumulado)
        retornos_tensor = torch.tensor(retornos)
        retornos_norm = (retornos_tensor - retornos_tensor.mean()) / (retornos_tensor.std() + 1e-9)
        
        perdida = 0
        obs = env.reset()
        tensor_obs = torch.FloatTensor(obs).unsqueeze(0)
        finalizado = False
        while not finalizado:
            probs = politica(tensor_obs)
            distribucion = torch.distributions.Categorical(probs)
            accion = distribucion.sample()
            nueva_obs, _, finalizado, _ = env.step(accion.item())
            tensor_nueva_obs = torch.FloatTensor(nueva_obs).unsqueeze(0)
            tensor_obs = tensor_nueva_obs
            perdida -= distribucion.log_prob(accion)
        
        perdida_media = perdida * retornos_norm.mean()
        optimizador.zero_grad()
        perdida_media.backward()
        optimizador.step()
    return recompensas_totales

2. Actor-Critic

Combina una red de política (Actor) que selecciona acciones y una red de valor (Critic) que evalúa la bondad de dichas acciones.

class RedActor(nn.Module):
    # Arquitectura similar a la red de política, adaptada para el actor.

class RedCritic(nn.Module):
    def __init__(self, dim_state):
        super(RedCritic, self).__init__()
        self.capa1 = nn.Linear(dim_state, 128)
        self.capa2 = nn.Linear(128, 1)

    def forward(self, estado):
        x = torch.relu(self.capa1(estado))
        valor_estimado = self.capa2(x)
        return valor_estimado

def entrenar_actor_critic(env, actor, critic, opt_actor, opt_critic, episodios, gamma=0.99):
    # Lógica de entrenamiento que calcula la ventaja (recompensa - valor estimado)
    # y actualiza ambas redes mediante gradientes separados.

3. Rainbow-DQN

Integra múltiples mejoras al algoritmo DQN original, incluyendo Double DQN, Dueling DQN, Prioritized Experience Replay y otras técnicas para mejorar el rendimiento y la estabilidad.

4. PPO-discrete (Entornos de Acciones Discretas)

Versión de Proximal Policy Optimization para espacios de acciones discretas. Utiliza una función objetivo con recorte (clipping) para limitar el tamaño de las actualizaciones de política, favoreciendo la estabilidad del entrenamiento.

5. PPO-continous (Entornos de Acciones Continuas)

Adaptación de PPO para espacios de acciones continuos, donde las acciones se modelan generalmente con distribuciones gaussianas.

6. DDPG (Deep Deterministic Policy Gradient)

Algoritmo actor-critic diseñado para espacios de acción continuos. Utiliza una política determinista y redes objetivo para estabilizar el aprendizaje.

7. TD3 (Twin Delayed DDPG)

Mejora sustancial de DDPG que emplea dos redes críticas, retrasa las actualizaciones de la red de actor y añade ruido a las acciones objetivo para mitigar la sobreestimación de valores.

8. SAC (Soft Actor-Critic)

Basado en el principio de máxima entropía. Busca maximizar simultáneamente la recompensa esperada y la entropía de la política, lo que promueve una exploración más robusta y diversa.

9. PPO-discrete-RNN

Versión de PPO para acciones discretas que incorpora redes neuronales recurrentes (RNN) en su arquitectura, permitiendo al agente manejar dependencias temporales en la secuencia de observaciones.

Etiquetas: PyTorch aprendizaje por refuerzo REINFORCE Actor-Critic ppo

Publicado el 7-3 17:08

Friki Work