18_planet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understanding PlaNet (Deep Planning Network): A Complete Guide\n",
    "\n",
    "# Table of Contents\n",
    "\n",
    "- [Introduction: Model-Based RL with Latent Dynamics](#introduction)\n",
    "- [What is PlaNet?](#what-is-planet)\n",
    "  - [Core Idea: Learning Dynamics & Planning in Latent Space](#core-idea)\n",
    "- [Why PlaNet? The Power of Learned Models & Planning](#why-planet)\n",
    "- [Where and How PlaNet is Used](#where-and-how-planet-is-used)\n",
    "- [Mathematical Foundation of PlaNet](#mathematical-foundation-of-planet)\n",
    "  - [Latent Dynamics Model (Conceptual)](#latent-dynamics-model-conceptual)\n",
    "    - [Transition Model](#transition-model)\n",
    "    - [Reward Model](#reward-model)\n",
    "    - [Observation/Representation Model (Simplified)](#observationrepresentation-model-simplified)\n",
    "  - [Model Training Objective](#model-training-objective)\n",
    "  - [Planning with the Model: Cross-Entropy Method (CEM)](#planning-with-the-model-cross-entropy-method-cem)\n",
    "  - [Action Selection](#action-selection)\n",
    "- [Step-by-Step Explanation of PlaNet](#step-by-step-explanation-of-planet)\n",
    "- [Key Components of PlaNet](#key-components-of-planet)\n",
    "  - [World Model (Dynamics Model)](#world-model-dynamics-model)\n",
    "  - [Replay Buffer (Sequence-Based)](#replay-buffer-sequence-based)\n",
    "  - [Model Training Procedure](#model-training-procedure)\n",
    "  - [Planner (CEM)](#planner-cem)\n",
    "  - [Action Execution](#action-execution)\n",
    "  - [Hyperparameters](#hyperparameters)\n",
    "- [Practical Example: Pendulum Environment](#practical-example-pendulum-environment)\n",
    "  - [Why Pendulum for this PlaNet Example?](#why-pendulum-for-this-planet-example)\n",
    "- [Setting up the Environment](#setting-up-the-environment)\n",
    "- [Creating the Continuous Environment (Gymnasium)](#creating-the-continuous-environment-gymnasium)\n",
    "- [Implementing the PlaNet Algorithm](#implementing-the-planet-algorithm)\n",
    "  - [Defining the Dynamics Model (Simplified)](#defining-the-dynamics-model-simplified)\n",
    "  - [Defining the Sequence Replay Buffer](#defining-the-sequence-replay-buffer)\n",
    "  - [Implementing the CEM Planner](#implementing-the-cem-planner)\n",
    "  - [Model Training Function](#model-training-function)\n",
    "- [Running the PlaNet Algorithm](#running-the-planet-algorithm)\n",
    "  - [Hyperparameter Setup](#hyperparameter-setup)\n",
    "  - [Initialization](#initialization)\n",
    "  - [Training Loop](#training-loop)\n",
    "- [Visualizing the Learning Process](#visualizing-the-learning-process)\n",
    "- [Analyzing the Learned Policy (Testing)](#analyzing-the-learned-policy-testing)\n",
    "- [Common Challenges and Extensions of PlaNet](#common-challenges-and-extensions-of-planet)\n",
    "- [Conclusion](#conclusion)\n",
    "\n",
    "## Introduction: Model-Based RL with Latent Dynamics\n",
    "\n",
    "Model-based reinforcement learning aims to improve sample efficiency by learning a model of the environment's dynamics. This learned model can then be used for planning, allowing the agent to \"simulate\" potential futures and choose actions without necessarily interacting with the real environment for every decision. PlaNet (Deep Planning Network) is a prominent example of this approach, particularly distinguished by its learning of dynamics within a compact *latent space*, often directly from high-dimensional observations like images.\n",
    "\n",
    "## What is PlaNet?\n",
    "\n",
    "PlaNet is a model-based RL agent that learns a world model from experience and uses this model to plan future actions. Its key innovation lies in learning the dynamics model not in the raw observation space (e.g., pixels), but in a lower-dimensional *latent space*. This makes learning the model more tractable and planning more efficient.\n",
    "\n",
    "The typical PlaNet architecture involves:\n",
    "1.  **Learning a World Model:** Training a model (often a Recurrent State-Space Model or RSSM) that can predict future latent states, rewards, and potentially reconstruct observations, given past latent states and actions.\n",
    "2.  **Planning in Latent Space:** Using the learned model to simulate future trajectories entirely within the compact latent space. An optimization algorithm, like the Cross-Entropy Method (CEM), is used to find the sequence of actions that maximizes the predicted cumulative reward over a planning horizon.\n",
    "3.  **Action Execution:** Executing only the *first* action of the best plan found by the planner in the real environment.\n",
    "4.  **Data Collection:** Storing the real observed transitions (observations, actions, rewards) in a replay buffer to continually improve the world model.\n",
    "\n",
    "### Core Idea: Learning Dynamics & Planning in Latent Space\n",
    "Instead of predicting how every pixel will change (which is very hard), PlaNet learns a compressed representation (latent state $s_t$) that captures the essential information needed to predict future states ($s_{t+1}$) and rewards ($r_t$). Planning then operates on these fast-to-simulate latent dynamics.\n",
    "\n",
    "## Why PlaNet? The Power of Learned Models & Planning\n",
    "\n",
    "- **High Sample Efficiency:** By leveraging the learned model for planning, PlaNet can often learn effective policies with significantly fewer real environment interactions compared to model-free methods, especially on complex tasks with high-dimensional observations.\n",
    "- **Handling Image Inputs:** Learning dynamics in a latent space makes it feasible to build world models directly from images, bypassing the need for hand-engineered state representations.\n",
    "- **Effective Planning:** Planning over future latent states allows the agent to anticipate consequences and choose actions that lead to high long-term rewards according to its learned model.\n",
    "\n",
    "## Where and How PlaNet is Used\n",
    "\n",
    "PlaNet and its successors (like DreamerV1/V2/V3) have shown state-of-the-art performance, particularly in:\n",
    "\n",
    "1.  **Control from Pixels:** Tasks where the input is images and actions are continuous (e.g., DeepMind Control Suite benchmarks).\n",
    "2.  **Robotics Simulation:** Learning complex manipulation and locomotion skills from visual input.\n",
    "3.  **Sample-Constrained Domains:** Situations where real-world interaction is expensive or time-consuming.\n",
    "\n",
    "## Mathematical Foundation of PlaNet\n",
    "\n",
    "### Latent Dynamics Model (Conceptual)\n",
    "PlaNet learns a model of the world, often structured as a Recurrent State-Space Model (RSSM), which typically includes:\n",
    "\n",
    "- **Transition Model ($p(s_{t+1} | s_t, a_t)$):** Predicts the distribution of the next latent state given the current latent state $s_t$ and action $a_t$. Often involves a deterministic recurrent component ($h_{t+1} = f(h_t, s_t, a_t)$) and a stochastic latent state $s_{t+1} \\sim p(s_{t+1} | h_{t+1})$.\n",
    "- **Reward Model ($p(r_t | s_t)$):** Predicts the distribution of the immediate reward given the latent state $s_t$.\n",
    "- **Observation Model ($p(o_t | s_t)$):** Predicts (reconstructs) the observation $o_t$ given the latent state $s_t$. Crucial for grounding the latent space when learning from images.\n",
    "- **Encoder / Representation Model ($q(s_t | ...)$):** Infers the latent state $s_t$ from observations $o_t$ and potentially past context ($h_t$). In variational approaches, this is often a posterior $q(s_t | h_t, o_t)$.\n",
    "\n",
    "*Simplification for this Notebook:* We will use simpler MLP-based models for transitions and rewards directly on the environment's vector state, effectively treating the vector state as (part of) the latent state and skipping the image encoding/decoding.\n",
    "\n",
    "### Model Training Objective\n",
    "The world model is trained by maximizing the likelihood of the observed data (sequences of observations, actions, rewards) stored in the replay buffer. This is often achieved by minimizing a loss function based on the Evidence Lower Bound (ELBO) in variational approaches, which typically includes:\n",
    "- **Reconstruction Loss:** Minimizing the difference between predicted observations $\\hat{o}_t$ (from $p(o_t | s_t)$) and actual observations $o_t$.\n",
    "- **Reward Prediction Loss:** Minimizing the difference between predicted rewards $\\hat{r}_t$ (from $p(r_t | s_t)$) and actual rewards $r_t$.\n",
    "- **KL Divergence Regularizers:** Penalizing the difference between the inferred posterior $q(s_t | h_t, o_t)$ and a learned prior $p(s_t | h_t)$, encouraging a well-structured latent space.\n",
    "\n",
    "*Simplification for this Notebook:* We will train our simplified dynamics model by minimizing the Mean Squared Error (MSE) for predicting the *next state vector* and the *reward*.\n",
    "$$ L_{model} = \\mathbb{E}_{(s_t, a_t, r_t, s_{t+1}) \\sim \\mathcal{D}} [ || s_{t+1} - \\hat{s}_{t+1}(s_t, a_t) ||^2 + || r_t - \\hat{r}_t(s_t, a_t) ||^2 ] $$\n",
    "where $\\hat{s}_{t+1}$ and $\\hat{r}_t$ are the predictions from our learned model.\n",
    "\n",
    "### Planning with the Model: Cross-Entropy Method (CEM)\n",
    "Given the current state $s_t$ (or its latent representation) and the learned model $(\\hat{p}(\\cdot | s, a), \\hat{r}(\\cdot, \\cdot))$, the goal is to find the sequence of actions $a_t, ..., a_{t+H-1}$ over a planning horizon $H$ that maximizes the expected cumulative reward predicted by the model: $\\mathbb{E} [ \\sum_{k=t}^{t+H-1} \\gamma^{k-t} \\hat{r}_k ]$.\n",
    "\n",
    "CEM is a derivative-free optimization algorithm used for this:\n",
    "1.  **Initialization:** Define an initial distribution over action sequences (e.g., Gaussian $\\mathcal{N}(\\mu, \\Sigma)$ for each step in the horizon).\n",
    "2.  **Sampling:** Sample $J$ candidate action sequences $A_j = (a_{t}^{(j)}, ..., a_{t+H-1}^{(j)})$ from the current distribution.\n",
    "3.  **Evaluation:** For each sequence $A_j$, use the learned dynamics model to simulate the trajectory in latent space and predict the total reward $R_j = \\sum_{k=t}^{t+H-1} \\gamma^{k-t} \\hat{r}_k^{(j)}$.\n",
    "4.  **Selection:** Select the top $M$ (elite) action sequences with the highest predicted rewards $R_j$.\n",
    "5.  **Refitting:** Update the parameters $(\\mu, \\Sigma)$ of the action sequence distribution based on the elite samples (e.g., compute the mean and variance of the elite sequences).\n",
    "6.  **Iteration:** Repeat steps 2-5 for a fixed number of iterations.\n",
    "7.  **Output:** The final mean $\\mu$ represents the best action sequence found. The first action $a_t = \\mu_t$ is executed.\n",
    "\n",
    "### Action Selection\n",
    "The action executed in the real environment at time $t$ is the first action $a_t^*$ from the best sequence found by the CEM planner: $a_t^* = \\text{Planner}(s_t, \\text{Model})$.\n",
    "\n",
    "## Step-by-Step Explanation of PlaNet\n",
    "\n",
    "1.  **Initialize**: Dynamics model (transition $\\hat{p}$, reward $\\hat{r}$), replay buffer $\\mathcal{D}$ (stores sequences). Hyperparameters (planning horizon $H$, CEM params $J, M$, model learning rate, etc.).\n",
    "2.  **Loop (Training Iterations/Environment Steps)**:\n",
    "    a.  **Interact & Collect Data**: \n",
    "        i.   Observe current state $s_t$.\n",
    "        ii.  Use CEM planner with the current model to find the best action sequence $a_t^*, ..., a_{t+H-1}^*$ starting from $s_t$.\n",
    "        iii. Execute the first action $a_t^*$ in the *real* environment.\n",
    "        iv.  Observe real reward $r_t$ and next state $s_{t+1}$.\n",
    "        v.   Store $(s_t, a_t^*, r_t, s_{t+1})$ in the replay buffer $\\mathcal{D}$.\n",
    "    b.  **Train World Model**: \n",
    "        i.   Sample a batch of sequences from $\\mathcal{D}$.\n",
    "        ii.  Train the dynamics model $(\\hat{p}, \\hat{r})$ to minimize the prediction loss (e.g., MSE for next state and reward) on the sampled sequences.\n",
    "    c.  $s_t \\leftarrow s_{t+1}$.\n",
    "3.  **Repeat**: Until convergence or max steps.\n",
    "\n",
    "## Key Components of PlaNet\n",
    "\n",
    "### World Model (Dynamics Model)\n",
    "- Learns to predict future states (latent or observed) and rewards from current state/latent state and action.\n",
    "- Trained on sequences of real experience.\n",
    "- Core component enabling planning.\n",
    "\n",
    "### Replay Buffer (Sequence-Based)\n",
    "- Stores sequences of transitions $(s_t, a_t, r_t, s_{t+1})$ or $(o_t, a_t, r_t, o_{t+1})$. Needed for training recurrent or sequence-based world models.\n",
    "\n",
    "### Model Training Procedure\n",
    "- Optimizes the world model parameters to accurately predict rewards and next states based on data from the replay buffer.\n",
    "\n",
    "### Planner (CEM)\n",
    "- Uses the learned world model to search for the optimal sequence of actions over a finite horizon $H$.\n",
    "- CEM is a common choice due to its simplicity and effectiveness in this context.\n",
    "\n",
    "### Action Execution\n",
    "- Only the first action from the planned sequence is executed in the real environment (Model Predictive Control principle).\n",
    "\n",
    "### Hyperparameters\n",
    "- Replay buffer size, batch size for model training.\n",
    "- Model learning rate, model architecture.\n",
    "- Planning horizon ($H$).\n",
    "- CEM parameters: iterations, candidates ($J$), elites ($M$), initial variance.\n",
    "\n",
    "## Practical Example: Pendulum Environment\n",
    "\n",
    "![Pendulum](data:image/png;base64,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)\n",
    "\n",
    "### Why Pendulum for this PlaNet Example?\n",
    "As mentioned, PlaNet typically uses image inputs. However, implementing the necessary vision components (CNNs) and latent models (RSSMs) is very complex for a didactic notebook. Pendulum provides a standard **continuous state and action space** where the benefits of model-based planning are still evident. We will adapt PlaNet to work with vector states, learning a model that predicts the next state vector $\\hat{s}_{t+1}$ and reward $\\hat{r}_t$ directly. This allows focusing on the interplay between model learning and CEM planning. **Requires `gymnasium`.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setting up the Environment\n",
    "\n",
    "Import libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cpu\n"
     ]
    }
   ],
   "source": [
    "# Import necessary libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "import math\n",
    "from collections import namedtuple, deque\n",
    "from itertools import count\n",
    "from typing import List, Tuple, Dict, Optional, Callable, Any\n",
    "import copy\n",
    "import time\n",
    "\n",
    "# Import PyTorch\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Normal, Independent\n",
    "from torch.distributions.kl import kl_divergence\n",
    "\n",
    "# Import Gymnasium\n",
    "try:\n",
    "    import gymnasium as gym\n",
    "except ImportError:\n",
    "    print(\"Gymnasium not found. Please install using 'pip install gymnasium' or 'pip install gym[classic_control]'\")\n",
    "    gym = None\n",
    "\n",
    "# Set up device\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "# Set random seeds\n",
    "seed = 42\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "torch.manual_seed(seed)\n",
    "if torch.cuda.is_available():\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Continuous Environment (Gymnasium)\n",
    "\n",
    "Instantiate Pendulum-v1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pendulum Environment:\n",
      "State Dim: 3\n",
      "Action Dim: 1\n",
      "Action Low: [-2.]\n",
      "Action High: [2.]\n"
     ]
    }
   ],
   "source": [
    "# Instantiate the Pendulum environment\n",
    "if gym is not None:\n",
    "    try:\n",
    "        env = gym.make('Pendulum-v1')\n",
    "        env.reset(seed=seed)\n",
    "        env.action_space.seed(seed)\n",
    "\n",
    "        n_observations_planet = env.observation_space.shape[0]\n",
    "        n_actions_planet = env.action_space.shape[0]\n",
    "        action_low_planet = env.action_space.low\n",
    "        action_high_planet = env.action_space.high\n",
    "\n",
    "        print(f\"Pendulum Environment:\")\n",
    "        print(f\"State Dim: {n_observations_planet}\")\n",
    "        print(f\"Action Dim: {n_actions_planet}\")\n",
    "        print(f\"Action Low: {action_low_planet}\")\n",
    "        print(f\"Action High: {action_high_planet}\")\n",
    "    except Exception as e:\n",
    "        print(f\"Error creating Gymnasium environment: {e}\")\n",
    "        n_observations_planet = 3\n",
    "        n_actions_planet = 1\n",
    "        action_low_planet = np.array([-2.0])\n",
    "        action_high_planet = np.array([2.0])\n",
    "        env = None\n",
    "else:\n",
    "    print(\"Gymnasium not available. Cannot create Pendulum environment.\")\n",
    "    n_observations_planet = 3\n",
    "    n_actions_planet = 1\n",
    "    action_low_planet = np.array([-2.0])\n",
    "    action_high_planet = np.array([2.0])\n",
    "    env = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Implementing the PlaNet Algorithm\n",
    "\n",
    "Define the simplified dynamics model, sequence replay buffer, CEM planner, and training functions.\n",
    "\n",
    "### Defining the Dynamics Model (Simplified)\n",
    "\n",
    "An MLP that takes current state $s_t$ and action $a_t$ and predicts next state $s_{t+1}$ and reward $r_t$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DynamicsModel(nn.Module):\n",
    "    \"\"\" Simplified MLP-based dynamics model for PlaNet. \"\"\"\n",
    "    def __init__(self, state_dim: int, action_dim: int, hidden_dim: int = 200):\n",
    "        super(DynamicsModel, self).__init__()\n",
    "        self.state_dim = state_dim\n",
    "        self.action_dim = action_dim\n",
    "        \n",
    "        # Simple MLP architecture\n",
    "        self.fc1 = nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        \n",
    "        # Output heads\n",
    "        self.fc_next_state = nn.Linear(hidden_dim, state_dim) # Predicts next state\n",
    "        self.fc_reward = nn.Linear(hidden_dim, 1)           # Predicts reward\n",
    "\n",
    "    def forward(self, state: torch.Tensor, action: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n",
    "        \"\"\"\n",
    "        Predicts the next state and reward.\n",
    "        \n",
    "        Parameters:\n",
    "        - state (torch.Tensor): Current state tensor.\n",
    "        - action (torch.Tensor): Action tensor.\n",
    "        \n",
    "        Returns:\n",
    "        - Tuple[torch.Tensor, torch.Tensor]:\n",
    "            - Predicted next state.\n",
    "            - Predicted reward.\n",
    "        \"\"\"\n",
    "        # Ensure inputs are 2D (batch_size, dim)\n",
    "        if state.dim() == 1: state = state.unsqueeze(0)\n",
    "        if action.dim() == 1: action = action.unsqueeze(0)\n",
    "        \n",
    "        x = torch.cat([state, action], dim=-1) # Concatenate state and action\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        \n",
    "        pred_next_state = self.fc_next_state(x)\n",
    "        pred_reward = self.fc_reward(x)\n",
    "        \n",
    "        # In a more complex model, might predict parameters of a distribution\n",
    "        # e.g., mean and variance for next state/reward.\n",
    "        # Here we just predict the mean directly.\n",
    "        \n",
    "        return pred_next_state, pred_reward"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining the Sequence Replay Buffer\n",
    "\n",
    "Stores sequences of transitions, needed for training sequence-based models (even our simplified MLP benefits from sequence context implicitly)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a transition structure for sequences\n",
    "# Store observations (o), actions (a), rewards (r), next_observations (o_next), dones (d)\n",
    "SeqTransition = namedtuple('SeqTransition',\n",
    "                           ('observations', 'actions', 'rewards', 'next_observations', 'dones'))\n",
    "\n",
    "class SequenceReplayBuffer:\n",
    "    \"\"\" Stores sequences of transitions. \"\"\"\n",
    "    def __init__(self, capacity: int, sequence_length: int):\n",
    "        self.capacity = capacity\n",
    "        self.sequence_length = sequence_length\n",
    "        self.buffer: List[Tuple[Any, ...]] = [] # Stores individual (o, a, r, o_next, d) steps\n",
    "        self.position = 0\n",
    "\n",
    "    def push(self, obs: np.ndarray, action: np.ndarray, reward: float, next_obs: np.ndarray, done: bool) -> None:\n",
    "        \"\"\" Add a single step transition to the buffer. \"\"\"\n",
    "        # Convert to numpy for storage efficiency if needed, or keep as tensors\n",
    "        transition = (obs, action, reward, next_obs, float(done)) \n",
    "        if len(self.buffer) < self.capacity:\n",
    "            self.buffer.append(None)\n",
    "        self.buffer[self.position] = transition\n",
    "        self.position = (self.position + 1) % self.capacity\n",
    "\n",
    "    def sample(self, batch_size: int) -> Optional[SeqTransition]:\n",
    "        \"\"\" Sample a batch of sequences. \"\"\"\n",
    "        if len(self.buffer) < self.sequence_length:\n",
    "            return None # Not enough data to form a sequence\n",
    "            \n",
    "        observations_batch = []\n",
    "        actions_batch = []\n",
    "        rewards_batch = []\n",
    "        next_observations_batch = []\n",
    "        dones_batch = []\n",
    "\n",
    "        for _ in range(batch_size):\n",
    "            # Choose a random starting point for the sequence\n",
    "            start_idx = random.randint(0, len(self.buffer) - self.sequence_length)\n",
    "            sequence = self.buffer[start_idx : start_idx + self.sequence_length]\n",
    "            \n",
    "            # Unzip the sequence\n",
    "            obs_seq, act_seq, rew_seq, next_obs_seq, done_seq = zip(*sequence)\n",
    "            \n",
    "            observations_batch.append(np.array(obs_seq))\n",
    "            actions_batch.append(np.array(act_seq))\n",
    "            rewards_batch.append(np.array(rew_seq))\n",
    "            next_observations_batch.append(np.array(next_obs_seq))\n",
    "            dones_batch.append(np.array(done_seq))\n",
    "\n",
    "        # Convert lists of sequences to tensors (batch_size, seq_len, feature_dim)\n",
    "        obs_tensor = torch.from_numpy(np.array(observations_batch)).float().to(device)\n",
    "        act_tensor = torch.from_numpy(np.array(actions_batch)).float().to(device)\n",
    "        rew_tensor = torch.from_numpy(np.array(rewards_batch)).float().to(device).unsqueeze(-1) # Add feature dim\n",
    "        next_obs_tensor = torch.from_numpy(np.array(next_observations_batch)).float().to(device)\n",
    "        dones_tensor = torch.from_numpy(np.array(dones_batch)).float().to(device).unsqueeze(-1) # Add feature dim\n",
    "\n",
    "        return SeqTransition(obs_tensor, act_tensor, rew_tensor, next_obs_tensor, dones_tensor)\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing the CEM Planner\n",
    "\n",
    "A function that performs CEM planning using the learned dynamics model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cem_planner(model: DynamicsModel, \n",
    "                initial_state: torch.Tensor, \n",
    "                horizon: int, \n",
    "                num_candidates: int, \n",
    "                num_elites: int, \n",
    "                num_iterations: int,\n",
    "                gamma: float, \n",
    "                action_low: np.ndarray, \n",
    "                action_high: np.ndarray,\n",
    "                action_dim: int) -> torch.Tensor:\n",
    "    \"\"\"\n",
    "    Performs Cross-Entropy Method (CEM) planning using the dynamics model.\n",
    "\n",
    "    Parameters:\n",
    "    - model: The learned DynamicsModel.\n",
    "    - initial_state: The state from which to start planning.\n",
    "    - horizon: Planning horizon (number of steps H).\n",
    "    - num_candidates: Number of action sequences to sample (J).\n",
    "    - num_elites: Number of top sequences to keep (M).\n",
    "    - num_iterations: Number of CEM refinement iterations.\n",
    "    - gamma: Discount factor for simulated rewards.\n",
    "    - action_low, action_high: Action space bounds.\n",
    "    - action_dim: Dimension of the action space.\n",
    "\n",
    "    Returns:\n",
    "    - torch.Tensor: The first action of the best sequence found.\n",
    "    \"\"\"\n",
    "    model.eval() # Set model to evaluation mode for planning\n",
    "\n",
    "    # Initialize action distribution (Gaussian)\n",
    "    # Mean initialized to zeros, std dev initialized to cover half the action range\n",
    "    action_mean = torch.zeros(horizon, action_dim, device=device)\n",
    "    action_std_dev = torch.ones(horizon, action_dim, device=device) * (torch.from_numpy(action_high - action_low).float().to(device) / 2.0)\n",
    "\n",
    "    for _ in range(num_iterations):\n",
    "        # Sample candidate action sequences from the current distribution\n",
    "        # Shape: (num_candidates, horizon, action_dim)\n",
    "        action_dist = Normal(action_mean, action_std_dev)\n",
    "        candidate_actions = action_dist.sample((num_candidates,))\n",
    "        \n",
    "        # Clip actions to bounds\n",
    "        action_low_t = torch.from_numpy(action_low).float().to(device)\n",
    "        action_high_t = torch.from_numpy(action_high).float().to(device)\n",
    "        candidate_actions = torch.clamp(candidate_actions, action_low_t, action_high_t)\n",
    "\n",
    "        # Evaluate candidate sequences using the model\n",
    "        total_rewards = torch.zeros(num_candidates, device=device)\n",
    "        current_states = initial_state.repeat(num_candidates, 1) # Start all candidates from initial state\n",
    "\n",
    "        with torch.no_grad(): # No gradients needed during model rollout\n",
    "            for t in range(horizon):\n",
    "                actions_t = candidate_actions[:, t, :] # Actions for this time step\n",
    "                # Predict next state and reward using the model\n",
    "                next_states, rewards = model(current_states, actions_t)\n",
    "                total_rewards += (gamma ** t) * rewards.squeeze() # Accumulate discounted reward\n",
    "                current_states = next_states # Move to predicted next state\n",
    "\n",
    "        # Select elite action sequences\n",
    "        _, elite_indices = torch.topk(total_rewards, num_elites) # Get indices of top M sequences\n",
    "        elite_actions = candidate_actions[elite_indices]\n",
    "        \n",
    "        # Refit the action distribution to the elite samples\n",
    "        action_mean = elite_actions.mean(dim=0)\n",
    "        action_std_dev = elite_actions.std(dim=0) + 1e-6 # Add epsilon for stability\n",
    "\n",
    "    # Return the mean of the first action in the final distribution\n",
    "    best_first_action = action_mean[0]\n",
    "    return best_first_action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Training Function\n",
    "\n",
    "Trains the dynamics model using sampled sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model: DynamicsModel, \n",
    "                model_optimizer: optim.Optimizer, \n",
    "                replay_buffer: SequenceReplayBuffer, \n",
    "                batch_size: int, \n",
    "                num_train_steps: int) -> float:\n",
    "    \"\"\"\n",
    "    Trains the dynamics model for a number of steps.\n",
    "    \n",
    "    Parameters:\n",
    "    - model: The DynamicsModel to train.\n",
    "    - model_optimizer: The optimizer for the model.\n",
    "    - replay_buffer: The sequence buffer to sample from.\n",
    "    - batch_size: The number of sequences per batch.\n",
    "    - num_train_steps: The number of gradient steps to perform.\n",
    "    \n",
    "    Returns:\n",
    "    - float: The average loss over the training steps.\n",
    "    \"\"\"\n",
    "    model.train() # Set model to training mode\n",
    "    total_loss = 0.0\n",
    "    steps_done = 0\n",
    "\n",
    "    for _ in range(num_train_steps):\n",
    "        # Sample a batch of sequences\n",
    "        sequence_batch = replay_buffer.sample(batch_size)\n",
    "        if sequence_batch is None:\n",
    "            continue # Not enough data yet\n",
    "            \n",
    "        obs_batch, act_batch, rew_batch, next_obs_batch, dones_batch = sequence_batch\n",
    "        # obs_batch shape: (batch_size, seq_len, state_dim)\n",
    "        # act_batch shape: (batch_size, seq_len, action_dim)\n",
    "        # rew_batch shape: (batch_size, seq_len, 1)\n",
    "        # next_obs_batch shape: (batch_size, seq_len, state_dim)\n",
    "\n",
    "        # --- Calculate Model Loss --- \n",
    "        # We need to predict next_state and reward for each step in the sequence.\n",
    "        # Here, we simplify and just predict based on the first step of each sequence \n",
    "        # for demonstration. A proper implementation would iterate through the sequence\n",
    "        # or use an RNN within the model.\n",
    "        \n",
    "        current_states = obs_batch[:, 0, :] # State at the start of sequence\n",
    "        current_actions = act_batch[:, 0, :] # Action at the start of sequence\n",
    "        target_next_states = next_obs_batch[:, 0, :] # True next state\n",
    "        target_rewards = rew_batch[:, 0, :]      # True reward\n",
    "\n",
    "        # Get model predictions\n",
    "        pred_next_states, pred_rewards = model(current_states, current_actions)\n",
    "        \n",
    "        # Calculate MSE losses\n",
    "        state_loss = F.mse_loss(pred_next_states, target_next_states)\n",
    "        reward_loss = F.mse_loss(pred_rewards, target_rewards)\n",
    "        \n",
    "        # Combine losses (can add weights if needed)\n",
    "        loss = state_loss + reward_loss\n",
    "        \n",
    "        # --- Optimize Model --- \n",
    "        model_optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        # Optional: Gradient clipping\n",
    "        # torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) \n",
    "        model_optimizer.step()\n",
    "        \n",
    "        total_loss += loss.item()\n",
    "        steps_done += 1\n",
    "\n",
    "    return total_loss / steps_done if steps_done > 0 else 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running the PlaNet Algorithm\n",
    "\n",
    "Set up hyperparameters, initialize components, and run the main PlaNet loop.\n",
    "\n",
    "### Hyperparameter Setup\n",
    "\n",
    "Define hyperparameters for PlaNet and CEM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters for PlaNet on Pendulum-v1\n",
    "BUFFER_CAPACITY_PLANET = int(1e5)   # Buffer stores individual steps\n",
    "SEQUENCE_LENGTH = 50              # Length of sequences sampled for model training\n",
    "MODEL_BATCH_SIZE = 32             # Number of sequences per model training batch\n",
    "MODEL_TRAIN_STEPS = 100           # Gradient steps for model per iteration\n",
    "MODEL_LR = 1e-3                   # Learning rate for the dynamics model\n",
    "HIDDEN_DIM_MODEL = 200            # Hidden dimension for the dynamics model\n",
    "\n",
    "# CEM Planner Hyperparameters\n",
    "PLANNING_HORIZON = 12             # How many steps ahead to plan (H)\n",
    "CEM_CANDIDATES = 1000             # Candidates sampled per CEM iteration (J)\n",
    "CEM_ELITES = 100                  # Elite samples to keep per CEM iteration (M)\n",
    "CEM_ITERATIONS = 10               # Number of CEM refinement iterations\n",
    "CEM_GAMMA = 0.99                  # Discount factor used *during planning*\n",
    "\n",
    "# Training Loop Hyperparameters\n",
    "NUM_ITERATIONS_PLANET = 50       # Number of Collect/Train iterations\n",
    "STEPS_PER_ITERATION_PLANET = 100  # Environment steps collected per iteration\n",
    "INITIAL_RANDOM_STEPS = 1000       # Collect initial data randomly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialization\n",
    "\n",
    "Initialize model, optimizer, and replay buffer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting 1000 initial random steps...\n",
      "Initial data collection complete.\n"
     ]
    }
   ],
   "source": [
    "if env is None:\n",
    "    raise RuntimeError(\"Gymnasium environment 'Pendulum-v1' could not be created.\")\n",
    "\n",
    "# Initialize Dynamics Model\n",
    "dynamics_model = DynamicsModel(n_observations_planet, \n",
    "                               n_actions_planet, \n",
    "                               HIDDEN_DIM_MODEL).to(device)\n",
    "\n",
    "# Initialize Model Optimizer\n",
    "model_optimizer = optim.Adam(dynamics_model.parameters(), lr=MODEL_LR)\n",
    "\n",
    "# Initialize Replay Buffer\n",
    "replay_buffer = SequenceReplayBuffer(BUFFER_CAPACITY_PLANET, SEQUENCE_LENGTH)\n",
    "\n",
    "# Lists for plotting\n",
    "planet_iteration_rewards = []\n",
    "planet_iteration_model_losses = []\n",
    "\n",
    "# --- Collect Initial Random Data --- \n",
    "print(f\"Collecting {INITIAL_RANDOM_STEPS} initial random steps...\")\n",
    "obs_np, _ = env.reset()\n",
    "for _ in range(INITIAL_RANDOM_STEPS):\n",
    "    action_np = env.action_space.sample()\n",
    "    next_obs_np, reward, terminated, truncated, _ = env.step(action_np)\n",
    "    done = terminated or truncated\n",
    "    replay_buffer.push(obs_np, action_np, reward, next_obs_np, done)\n",
    "    obs_np = next_obs_np\n",
    "    if done:\n",
    "        obs_np, _ = env.reset()\n",
    "print(\"Initial data collection complete.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Loop\n",
    "\n",
    "The PlaNet loop: Collect data using CEM planning, then train the world model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting PlaNet Training on Pendulum-v1...\n",
      "Iter 10/50 | Steps: 1000 | Avg Ep Reward: -492.32 | Model Loss: 0.040212\n",
      "Iter 20/50 | Steps: 2000 | Avg Ep Reward: -267.97 | Model Loss: 0.006726\n",
      "Iter 30/50 | Steps: 3000 | Avg Ep Reward: -519.70 | Model Loss: 0.004455\n",
      "Iter 40/50 | Steps: 4000 | Avg Ep Reward: -151.99 | Model Loss: 0.003335\n",
      "Iter 50/50 | Steps: 5000 | Avg Ep Reward: -0.64 | Model Loss: 0.002298\n",
      "Pendulum-v1 Training Finished (PlaNet).\n"
     ]
    }
   ],
   "source": [
    "print(\"Starting PlaNet Training on Pendulum-v1...\")\n",
    "\n",
    "# --- PlaNet Training Loop ---\n",
    "total_steps_planet = 0\n",
    "current_state_np, _ = env.reset()\n",
    "current_state = torch.from_numpy(current_state_np).float().to(device)\n",
    "\n",
    "for iteration in range(1, NUM_ITERATIONS_PLANET + 1):\n",
    "    # --- 1. Collect Data using Planner --- \n",
    "    iteration_rewards_list = []\n",
    "    current_episode_reward = 0.0\n",
    "    steps_this_iter = 0\n",
    "    \n",
    "    while steps_this_iter < STEPS_PER_ITERATION_PLANET:\n",
    "        # Plan action using CEM\n",
    "        action_tensor = cem_planner(\n",
    "            dynamics_model,\n",
    "            current_state,\n",
    "            horizon=PLANNING_HORIZON,\n",
    "            num_candidates=CEM_CANDIDATES,\n",
    "            num_elites=CEM_ELITES,\n",
    "            num_iterations=CEM_ITERATIONS,\n",
    "            gamma=CEM_GAMMA, # Use planning discount\n",
    "            action_low=action_low_planet,\n",
    "            action_high=action_high_planet,\n",
    "            action_dim=n_actions_planet\n",
    "        )\n",
    "        action_np = action_tensor.detach().cpu().numpy()\n",
    "        # Clip just in case CEM produces values slightly out of bounds\n",
    "        action_np_clipped = np.clip(action_np, action_low_planet, action_high_planet)\n",
    "\n",
    "        # Interact with environment\n",
    "        next_state_np, reward, terminated, truncated, _ = env.step(action_np_clipped)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        # Store experience\n",
    "        replay_buffer.push(current_state_np, action_np_clipped, reward, next_state_np, done)\n",
    "        \n",
    "        current_state_np = next_state_np\n",
    "        current_state = torch.from_numpy(current_state_np).float().to(device)\n",
    "        current_episode_reward += reward\n",
    "        total_steps_planet += 1\n",
    "        steps_this_iter += 1\n",
    "        \n",
    "        if done:\n",
    "            iteration_rewards_list.append(current_episode_reward)\n",
    "            current_state_np, _ = env.reset()\n",
    "            current_state = torch.from_numpy(current_state_np).float().to(device)\n",
    "            current_episode_reward = 0.0\n",
    "            # Check if iteration step limit reached even if episode ended early\n",
    "            if steps_this_iter >= STEPS_PER_ITERATION_PLANET:\n",
    "                break\n",
    "                \n",
    "    # --- 2. Train World Model --- \n",
    "    avg_model_loss = train_model(dynamics_model, model_optimizer, replay_buffer,\n",
    "                                 MODEL_BATCH_SIZE, MODEL_TRAIN_STEPS)\n",
    "\n",
    "    # --- Logging --- \n",
    "    avg_iter_reward = np.mean(iteration_rewards_list) if iteration_rewards_list else np.nan\n",
    "    planet_iteration_rewards.append(avg_iter_reward)\n",
    "    planet_iteration_model_losses.append(avg_model_loss)\n",
    "    \n",
    "    if iteration % 10 == 0:\n",
    "        print(f\"Iter {iteration}/{NUM_ITERATIONS_PLANET} | Steps: {total_steps_planet} | Avg Ep Reward: {avg_iter_reward:.2f} | Model Loss: {avg_model_loss:.6f}\")\n",
    "\n",
    "print(\"Pendulum-v1 Training Finished (PlaNet).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the Learning Process\n",
    "\n",
    "Plot average episode rewards per iteration and the model training loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting results for PlaNet on Pendulum-v1\n",
    "plt.figure(figsize=(12, 4))\n",
    "\n",
    "# Average Episode Rewards per Iteration\n",
    "plt.subplot(1, 2, 1)\n",
    "valid_rewards_planet = [r for r in planet_iteration_rewards if not np.isnan(r)]\n",
    "valid_indices_planet = [i for i, r in enumerate(planet_iteration_rewards) if not np.isnan(r)]\n",
    "plt.plot(valid_indices_planet, valid_rewards_planet)\n",
    "plt.title('PlaNet Pendulum: Avg Episode Reward / Iteration')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Avg Reward')\n",
    "plt.grid(True)\n",
    "if len(valid_rewards_planet) >= 10:\n",
    "    rewards_ma_planet = np.convolve(valid_rewards_planet, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(valid_indices_planet[9:], rewards_ma_planet, label='10-iter MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "# Model Loss per Iteration\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(planet_iteration_model_losses)\n",
    "plt.title('PlaNet Pendulum: Avg Model Loss / Iteration')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Avg MSE Loss (State+Reward)')\n",
    "plt.yscale('log') # Loss often decreases significantly, log scale helps\n",
    "plt.grid(True, which='both')\n",
    "if len(planet_iteration_model_losses) >= 10:\n",
    "    mloss_ma_planet = np.convolve(planet_iteration_model_losses, np.ones(10)/10, mode='valid')\n",
    "    plt.plot(np.arange(len(mloss_ma_planet)) + 9, mloss_ma_planet, label='10-iter MA', color='orange')\n",
    "    plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Analysis of PlaNet Learning Curves (Pendulum):**\n",
    "\n",
    "1.  **Avg Episode Reward / Iteration (Left Plot):**\n",
    "    *   **Observation:** This plot shows an extremely rapid initial phase of learning. Starting from very poor performance (~-800), the average reward shoots up dramatically within the first 15-20 iterations, reaching values close to the optimal range (approaching 0). Following this steep ascent, the reward exhibits significant instability, with large oscillations between near-optimal performance and much lower rewards (-400 or worse). The 10-iteration moving average (orange line) captures the overall high level achieved after the initial learning but smooths over these pronounced peaks and troughs.\n",
    "    *   **Interpretation:** The rapid initial improvement highlights the potential sample efficiency of PlaNet. By learning a dynamics model, it can quickly leverage simulated experience (\"planning\") to find decent policies with relatively few real environment interactions. The subsequent volatility, however, is crucial. It suggests that while the learned model is good enough for initial progress, it likely contains inaccuracies. The planner (CEM in PlaNet) might find action sequences that yield high rewards *according to the imperfect model*, but these plans don't perfectly translate to the real environment, leading to performance drops. This discrepancy between model-based plans and real-world outcomes causes the observed oscillations.\n",
    "\n",
    "2.  **Avg Model Loss / Iteration (Right Plot):**\n",
    "    *   **Observation:** This plot shows the average Mean Squared Error (MSE) loss for the world model's predictions (next state and reward) on a logarithmic scale. The loss decreases very rapidly by several orders of magnitude during the first ~15 iterations, corresponding precisely with the period of fastest reward improvement. After this initial drop, the loss stabilizes at a low average value (around 0.01-0.02), with some minor fluctuations later in training.\n",
    "    *   **Interpretation:** The sharp initial decrease confirms that the world model component of PlaNet is learning effectively and quickly capturing the short-term dynamics of the Pendulum environment from the collected experience. This ability to quickly build a reasonably predictive model is what enables the fast initial policy improvement seen in the reward plot. The stabilization indicates the model has reached a certain level of accuracy, likely limited by the complexity of the dynamics, the model capacity, and the quality/diversity of the collected data. Even a low average loss doesn't guarantee perfect long-term predictions, which is essential for the multi-step planning phase.\n",
    "\n",
    "**Overall Conclusion:**\n",
    "PlaNet demonstrates impressive initial sample efficiency on the Pendulum task, rapidly improving rewards by learning a predictive world model and planning using it. The model loss converges quickly to low values, indicating good short-term prediction capabilities. However, the pronounced volatility in rewards after the initial learning phase suggests that inaccuracies in the learned model are amplified by the multi-step planning process (CEM). This leads to plans that are optimal within the learned model but suboptimal or unstable when executed in the true environment, highlighting the challenge of model bias in model-based reinforcement learning, especially for continuous control tasks requiring precise long-horizon predictions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analyzing the Learned Policy (Testing)\n",
    "\n",
    "Visualize the performance of the PlaNet agent by running it in the environment, using the planner at each step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "--- Testing PlaNet Agent (3 episodes) ---\n",
      "Test Episode 1: Reward = -1765.54, Length = 200\n",
      "Test Episode 2: Reward = -4.07, Length = 200\n",
      "Test Episode 3: Reward = -392.67, Length = 200\n",
      "--- Testing Complete. Average Reward: -720.76 ---\n"
     ]
    }
   ],
   "source": [
    "def test_planet_agent(model: DynamicsModel, \n",
    "                      env_instance: gym.Env, \n",
    "                      num_episodes: int = 5, \n",
    "                      render: bool = False, \n",
    "                      seed_offset: int = 3000, \n",
    "                      cem_params: dict = {}) -> None:\n",
    "    \"\"\"\n",
    "    Tests the trained PlaNet agent using CEM planning at each step.\n",
    "    \"\"\"\n",
    "    if env_instance is None:\n",
    "        print(\"Environment not available for testing.\")\n",
    "        return\n",
    "        \n",
    "    model.eval() # Set model to evaluation mode\n",
    "    \n",
    "    # Get CEM params or use defaults\n",
    "    horizon = cem_params.get('horizon', PLANNING_HORIZON)\n",
    "    candidates = cem_params.get('candidates', CEM_CANDIDATES)\n",
    "    elites = cem_params.get('elites', CEM_ELITES)\n",
    "    iterations = cem_params.get('iterations', CEM_ITERATIONS)\n",
    "    gamma = cem_params.get('gamma', CEM_GAMMA)\n",
    "    action_dim = env_instance.action_space.shape[0]\n",
    "    action_low = env_instance.action_space.low\n",
    "    action_high = env_instance.action_space.high\n",
    "\n",
    "    print(f\"\\n--- Testing PlaNet Agent ({num_episodes} episodes) ---\")\n",
    "    all_rewards = []\n",
    "    for i in range(num_episodes):\n",
    "        state_np, info = env_instance.reset(seed=seed + seed_offset + i)\n",
    "        state = torch.from_numpy(state_np).float().to(device)\n",
    "        episode_reward = 0\n",
    "        done = False\n",
    "        t = 0\n",
    "        while not done:\n",
    "            if render:\n",
    "                try:\n",
    "                    env_instance.render()\n",
    "                    time.sleep(0.01)\n",
    "                except Exception as e:\n",
    "                    print(f\"Rendering failed: {e}. Disabling render.\")\n",
    "                    render = False\n",
    "            \n",
    "            # Plan action using CEM\n",
    "            action_tensor = cem_planner(\n",
    "                model, state, horizon, candidates, elites, iterations, gamma,\n",
    "                action_low, action_high, action_dim\n",
    "            )\n",
    "            action_np = action_tensor.detach().cpu().numpy()\n",
    "            action_np_clipped = np.clip(action_np, action_low, action_high)\n",
    "            \n",
    "            # Step environment\n",
    "            next_state_np, reward, terminated, truncated, _ = env_instance.step(action_np_clipped)\n",
    "            done = terminated or truncated\n",
    "            state = torch.from_numpy(next_state_np).float().to(device)\n",
    "            episode_reward += reward\n",
    "            t += 1\n",
    "        \n",
    "        print(f\"Test Episode {i+1}: Reward = {episode_reward:.2f}, Length = {t}\")\n",
    "        all_rewards.append(episode_reward)\n",
    "        if render:\n",
    "             env_instance.close()\n",
    "\n",
    "    print(f\"--- Testing Complete. Average Reward: {np.mean(all_rewards):.2f} ---\")\n",
    "\n",
    "# Run test episodes (ensure env is still available)\n",
    "# Pass CEM parameters used during training (or potentially refined ones)\n",
    "test_cem_params = {\n",
    "    'horizon': PLANNING_HORIZON,\n",
    "    'candidates': CEM_CANDIDATES,\n",
    "    'elites': CEM_ELITES,\n",
    "    'iterations': CEM_ITERATIONS,\n",
    "    'gamma': CEM_GAMMA\n",
    "}\n",
    "test_planet_agent(dynamics_model, env, num_episodes=3, render=False, cem_params=test_cem_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Challenges and Extensions of PlaNet\n",
    "\n",
    "**Challenge: Model Accuracy vs. Complexity**\n",
    "*   **Problem:** Learning an accurate world model, especially from high-dimensional data like images or for complex dynamics, is inherently difficult. Simple models might be inaccurate, while complex models (like full RSSMs) are hard to train and computationally expensive.\n",
    "*   **Solutions**:\n",
    "    *   **Better Model Architectures:** Using more sophisticated sequence models (RSSM, Transformers) designed for dynamics modeling.\n",
    "    *   **Probabilistic Models:** Predicting distributions over next states/rewards captures uncertainty.\n",
    "    *   **Careful Regularization:** Techniques like KL regularization in variational models help structure the latent space.\n",
    "    *   **Focus on Relevant Information:** Design models to predict only what's necessary for planning.\n",
    "\n",
    "**Challenge: Compounding Model Errors**\n",
    "*   **Problem:** During planning (simulating over horizon $H$), small prediction errors at each step can accumulate, leading to inaccurate long-term predictions and potentially poor plans.\n",
    "*   **Solutions**:\n",
    "    *   **Shorter Planning Horizon ($H$):** Reduces the potential for error accumulation but might lead to myopic behavior.\n",
    "    *   **More Accurate Models:** Improving the single-step prediction accuracy.\n",
    "    *   **Model Ensemble:** Train multiple models and average their predictions during planning.\n",
    "    * **Re-planning:** Frequently re-plan from the current *real* state to correct for deviations.\n",
    "\n",
    "**Challenge: Planning Cost**\n",
    "*   **Problem:** Performing iterative optimization like CEM at every time step can be computationally expensive, limiting real-time application.\n",
    "   **Solutions**:\n",
    "    *   **Efficient Planners:** Investigate faster planning algorithms (e.g., gradient-based trajectory optimization if the model is differentiable, or optimized CEM implementations).\n",
    "    *   **Reduce CEM Parameters:** Decrease candidates ($J$), elites ($M$), or iterations, trading off planning quality for speed.\n",
    "    *   **Plan Less Frequently:** Execute multiple actions from a single plan before re-planning.\n",
    "    *   **Amortized Planning (Policy Learning):** Train a separate policy network (actor) using the planner's outputs as targets (as done in later algorithms like Dreamer), effectively distilling the planning computation into a fast policy network.\n",
    "\n",
    "**Challenge: Discrepancy between Model and Reality (Sim-to-Real Gap)**\n",
    "*   **Problem:** Even a well-trained model is an approximation. Policies optimized entirely within the model might not transfer perfectly to the real world.\n",
    "*   **Solutions**:\n",
    "    *   **Continuous Model Updates:** Keep training the model with new real data.\n",
    "    *   **Robust Planning:** Use techniques that account for model uncertainty during planning.\n",
    "    *   **System Identification:** Techniques to explicitly improve model accuracy in relevant parts of the state space.\n",
    "\n",
    "**Extensions (Dreamer Family):**\n",
    "- **DreamerV1/V2/V3:** Successors to PlaNet that build upon the core ideas. They typically use more advanced RSSMs, learn policy and value functions *within the latent space* using imagined trajectories, and often achieve even higher sample efficiency and performance.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "PlaNet represents a powerful paradigm in model-based reinforcement learning, demonstrating the potential of learning world models, particularly in latent space, and leveraging them for planning. By decoupling model learning from policy execution, it aims for high sample efficiency, making it suitable for complex tasks, especially those with high-dimensional observations like images.\n",
    "\n",
    "The core loop involves collecting experience, training the latent dynamics model (predicting states and rewards), and using a planner like CEM to find optimal action sequences based on the model's simulations. While facing challenges related to model accuracy, compounding errors, and planning cost, PlaNet's approach of planning in a learned latent space has been highly influential, paving the way for subsequent state-of-the-art algorithms like the Dreamer series."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv-all-rl-algos",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}