Muestreo del búfer PER

Antes de que puedas utilizar la clase Tampón de Experiencias Priorizadas para entrenar a tu agente, todavía tienes que implementar el método .sample(). Este método toma como argumento el tamaño de la muestra que quieres dibujar, y devuelve las transiciones muestreadas como tensors, junto con sus índices en el búfer de memoria y su peso de importancia.

Se ha precargado un buffer con capacidad 10 en tu entorno para que tomes muestras de él.

Este ejercicio forma parte del curso

Aprendizaje profundo por refuerzo en Python

Instrucciones de ejercicio

Calcula la probabilidad de muestreo asociada a cada transición.
Dibuja los índices correspondientes a las transiciones de la muestra; np.random.choice(a, s, p=p) toma una muestra de tamaño s con reemplazamiento de la matriz a, basándose en la matriz de probabilidad p.
Calcula el peso de importancia asociado a cada transición.

Ejercicio interactivo práctico

Pruebe este ejercicio completando este código de muestra.

def sample(self, batch_size):
    priorities = np.array(self.priorities)
    # Calculate the sampling probabilities
    probabilities = ____ / np.sum(____)
    # Draw the indices for the sample
    indices = np.random.choice(____)
    # Calculate the importance weights
    weights = (1 / (len(self.memory) * ____)) ** ____
    weights /= np.max(weights)
    states, actions, rewards, next_states, dones = zip(*[self.memory[idx] for idx in indices])
    weights = [weights[idx] for idx in indices]
    states_tensor = torch.tensor(states, dtype=torch.float32)
    rewards_tensor = torch.tensor(rewards, dtype=torch.float32)
    next_states_tensor = torch.tensor(next_states, dtype=torch.float32)
    dones_tensor = torch.tensor(dones, dtype=torch.float32)
    weights_tensor = torch.tensor(weights, dtype=torch.float32)
    actions_tensor = torch.tensor(actions, dtype=torch.long).unsqueeze(1)
    return (states_tensor, actions_tensor, rewards_tensor, next_states_tensor,
            dones_tensor, indices, weights_tensor)

PrioritizedReplayBuffer.sample = sample
print("Sampled transitions:\n", buffer.sample(3))

Editar y ejecutar código

Este ejercicio forma parte del curso

Aprendizaje profundo por refuerzo en Python

AvanzadoNivel de habilidad

4.8+

Comienza el curso gratis

Descubre cómo el Aprendizaje por Refuerzo Profundo mejora el Aprendizaje por Refuerzo tradicional mientras estudias e implementas tu primer algoritmo de Aprendizaje Q Profundo.

Exercise 1: Introducción al aprendizaje profundo por refuerzo Exercise 2: Entorno y configuración de la red neuronal Exercise 3: DRL bucle de entrenamiento Exercise 4: Introducción al aprendizaje profundo Q Exercise 5: Aprendizaje profundo y DQN Exercise 6: La arquitectura Q-Network Exercise 7: Instanciar la red Q Exercise 8: El algoritmo barebone DQN Exercise 9: Barebone DQN selección de acciones Exercise 10: Barebone DQN función de pérdida Exercise 11: Entrenar el barebone DQN

Sumérgete en el Aprendizaje Q Profundo implementando el algoritmo original DQN, que incluye la Repetición de Experiencias, la gradación épsilon y los objetivos Q fijos. Más allá de DQN, explorarás dos fascinantes extensiones que mejoran el rendimiento y la estabilidad del aprendizaje Q profundo: Doble DQN y Repetición de Experiencias Priorizadas.

Exercise 1: DQN con repetición de experiencia Exercise 2: La cola doble Exercise 3: Búfer de repetición de experiencia Exercise 4: DQN con repetición de experiencia Exercise 5: El algoritmo completo de DQN Exercise 6: Epsilon-greediness Exercise 7: Objetivos Q fijos Exercise 8: Aplicación del algoritmo completo DQN Exercise 9: Doble DQN Exercise 10: Red en línea y red de destino en DDQN Exercise 11: Entrenamiento del doble DQN Exercise 12: Repetición priorizada de la experiencia Exercise 13: Buffer de repetición de experiencia priorizada Exercise 14: Muestreo del búfer PER

Ejercicio actual

Exercise 15: DQN con repetición priorizada de experiencias

Conoce los conceptos fundamentales de los métodos de gradiente político que se encuentran en DRL. Empezarás con el teorema del gradiente político, que constituye la base de estos métodos. A continuación, pondrás en práctica el algoritmo REINFORCE, un potente método de aprendizaje de políticas. A continuación, el capítulo te guiará a través de los métodos Actor-Crítico, centrándose en el algoritmo Actor-Crítico de Ventaja (A2C), que combina los puntos fuertes de los métodos basados en el gradiente de la política y en el valor para mejorar la eficacia y la estabilidad del aprendizaje.

Exercise 1: Introducción al gradiente político Exercise 2: La arquitectura de la red política Exercise 3: Trabajar con distribuciones discretas Exercise 4: Gradiente político y REINFORCE Exercise 5: Selección de acciones en REINFORCE Exercise 6: Entrenamiento del algoritmo REINFORCE Exercise 7: Ventaja Actor Crítico Exercise 8: Red de críticos Exercise 9: Cálculo de las pérdidas del Actor Crítico Exercise 10: Entrenamiento del algoritmo A2C

Explora la Optimización de la Política Proximal (PPO) para un rendimiento sólido de DRL. A continuación, examinarás el uso de un bono de entropía en PPO, que fomenta la exploración evitando la convergencia prematura a políticas deterministas. También aprenderás sobre las actualizaciones por lotes en los métodos de gradiente de política. Por último, aprenderás sobre la optimización de hiperparámetros con Optuna, una potente herramienta para optimizar el rendimiento de tus modelos DRL.

Exercise 1: Optimización de la política proximal Exercise 2: La relación de probabilidad recortada Exercise 3: La función objetivo sustitutiva recortada Exercise 4: Bonificación por entropía y PPO Exercise 5: Parque infantil Entropía Exercise 6: Entrenamiento del algoritmo PPO Exercise 7: Actualizaciones por lotes en gradiente de política Exercise 8: Minilotes y DRL Exercise 9: A2C con actualizaciones por lotes Exercise 10: Optimización de hiperparámetros con Optuna Exercise 11: ¿Hiperparámetro o no?Exercise 12: Práctica con Optuna Exercise 13: ¡Enhorabuena!