ddpg.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "576aeedf-9adf-418d-89f1-07309265c327",
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import random\n",
    "import argparse\n",
    "import os\n",
    "import sys\n",
    "import copy\n",
    "import pygame\n",
    "import gymnasium as gym\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from collections import namedtuple, deque\n",
    "from pathlib import Path\n",
    "\n",
    "from tqdm.autonotebook import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "3e630441-d962-4cdb-a3be-152d52535fbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Configure logging\n",
    "logging.basicConfig(\n",
    "    level=logging.INFO,\n",
    "    format='%(asctime)s - %(levelname)s - %(message)s',\n",
    "    datefmt='%Y-%m-%d %H:%M:%S'\n",
    ")\n",
    "logger = logging.getLogger(__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "babdc161-0587-49b3-a8cf-2e393ad29e45",
   "metadata": {},
   "outputs": [],
   "source": [
    "BUFFER_SIZE = int(1e5)\n",
    "BATCH_SIZE = 128\n",
    "GAMMA = 0.99\n",
    "TAU = 1e-3\n",
    "STEP_SIZE_ACTOR = 1e-4\n",
    "STEP_SIZE_CRITIC = 1e-3\n",
    "WEIGHT_DECAY = 0.\n",
    "UPDATE_Q_NETWORK_EVERY_STEPS = 1\n",
    "\n",
    "LOG_EVERY_STEPS = 100\n",
    "PATH_SAVE_DIR = \"./checkpoints/ddpg\"\n",
    "\n",
    "MAX_AVG_REWARD = 0.\n",
    "\n",
    "NUM_EPISODES=1000\n",
    "MAX_STEPS_EP=200\n",
    "EPS_START=0.9\n",
    "EPS_END=0.05\n",
    "EPS_DECAY=0.995\n",
    "SEED=1278173123\n",
    "\n",
    "SAVE_EVERY_NTH=100\n",
    "\n",
    "NUM_EPISODES_TEST = 1000\n",
    "\n",
    "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "PLOT = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "07c478cc-4fda-425e-8ea2-78b44d51d2da",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "random.seed(SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "03f40d5f-d9d7-48d7-8036-043293b9d20f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_scores(scores, scores_avg, show=False, fname=None):\n",
    "    \"\"\"Plot scores over last 100 episodes.\"\"\"\n",
    "    fig = plt.figure()\n",
    "    fig.add_subplot(111)\n",
    "    plt.plot(np.arange(len(scores)), scores, c=\"#6200ee\", alpha=0.7)\n",
    "    plt.plot(scores_avg, c=\"#03dac6\")\n",
    "    plt.ylabel(\"Score\")\n",
    "    plt.xlabel(\"Episodes\")\n",
    "\n",
    "    if fname:\n",
    "        plt.savefig(fname)\n",
    "\n",
    "    if show:\n",
    "        plt.show()\n",
    "\n",
    "    plt.close()\n",
    "\n",
    "\n",
    "def save_checkpoint(state, filename):\n",
    "    \"\"\"Save state to filename.\"\"\"\n",
    "    torch.save(state, filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "bf491e3c-9f11-40b5-a0a6-e97860daa06d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hidden_init(layer):\n",
    "    fan_in = layer.weight.data.size()[1]\n",
    "    lim = 1.0 / np.sqrt(fan_in)\n",
    "    return (-lim, lim)\n",
    "\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    \"\"\"Actor (Policy) Model.\"\"\"\n",
    "\n",
    "    def __init__(self, state_size, action_size, seed, fc1_units=400, fc2_units=300):\n",
    "        super(Actor, self).__init__()\n",
    "        self.fc1 = nn.Linear(state_size, fc1_units)\n",
    "        self.bn1 = nn.BatchNorm1d(num_features=fc1_units)\n",
    "\n",
    "        self.fc2 = nn.Linear(fc1_units, fc2_units)\n",
    "        self.bn2 = nn.BatchNorm1d(num_features=fc2_units)\n",
    "\n",
    "        self.fc3 = nn.Linear(fc2_units, action_size)\n",
    "        self.reset_parameters()\n",
    "\n",
    "    \n",
    "    def reset_parameters(self):\n",
    "        self.fc1.weight.data.uniform_(*hidden_init(self.fc1))\n",
    "        self.fc2.weight.data.uniform_(*hidden_init(self.fc2))\n",
    "        self.fc3.weight.data.uniform_(-3e-3, 3e-3)\n",
    "\n",
    "    \n",
    "    def forward(self, state):\n",
    "        \"\"\"Build an actor (policy) network that maps states -> actions.\"\"\"\n",
    "        x = self.bn1(F.relu(self.fc1(state)))\n",
    "        x = self.bn2(F.relu(self.fc2(x)))\n",
    "        return F.tanh(self.fc3(x))\n",
    "\n",
    "\n",
    "class Critic(nn.Module):\n",
    "    \"\"\"Critic (Value) Model.\"\"\"\n",
    "\n",
    "    def __init__(self, state_size, action_size, seed, fc1_units=400, fc2_units=300):\n",
    "        super(Critic, self).__init__()\n",
    "        self.fc1 = nn.Linear(state_size, fc1_units)\n",
    "        self.bn1 = nn.BatchNorm1d(num_features=fc1_units)\n",
    "\n",
    "        self.fc2 = nn.Linear(fc1_units + action_size, fc2_units)\n",
    "        self.fc3 = nn.Linear(fc2_units, 1)\n",
    "        self.reset_parameters()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        self.fc1.weight.data.uniform_(*hidden_init(self.fc1))\n",
    "        self.fc2.weight.data.uniform_(*hidden_init(self.fc2))\n",
    "        self.fc3.weight.data.uniform_(-3e-3, 3e-3)\n",
    "\n",
    "    def forward(self, state, action):\n",
    "        \"\"\"Build a critic (value) network that maps (state, action) pairs -> Q-values.\"\"\"\n",
    "        x = self.bn1(F.leaky_relu(self.fc1(state)))\n",
    "        x = torch.cat((x, action), dim=1)\n",
    "        x = F.leaky_relu(self.fc2(x))\n",
    "        return self.fc3(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "e483e2cb-448c-46ef-9068-6ad044200062",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DDPGAgent:\n",
    "    \"\"\"Interacts with and learns from the environment.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        state_size,\n",
    "        action_size,\n",
    "        buffer_size=int(1e5),\n",
    "        batch_size=128,\n",
    "        gamma=0.99,\n",
    "        tau=1e-3,\n",
    "        step_size_actor=1e-4,\n",
    "        step_size_critic=1e-3,\n",
    "        weight_decay=0,\n",
    "        random_seed=2,\n",
    "        device=\"cpu\",\n",
    "    ):\n",
    "        self.state_size = state_size\n",
    "        self.action_size = action_size\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.device = device\n",
    "\n",
    "        self.actor_local = Actor(state_size, action_size, random_seed).to(device)\n",
    "        self.actor_target = Actor(state_size, action_size, random_seed).to(device)\n",
    "        self.actor_optimizer = optim.Adam(self.actor_local.parameters(), lr=step_size_actor)\n",
    "\n",
    "        self.critic_local = Critic(state_size, action_size, random_seed).to(device)\n",
    "        self.critic_target = Critic(state_size, action_size, random_seed).to(device)\n",
    "        self.critic_optimizer = optim.Adam(\n",
    "            self.critic_local.parameters(),\n",
    "            lr=step_size_critic,\n",
    "            weight_decay=weight_decay,\n",
    "        )\n",
    "\n",
    "        self.noise = OUNoise(action_size, random_seed)\n",
    "\n",
    "        self.memory = ReplayBuffer(\n",
    "            action_size=action_size,\n",
    "            buffer_size=buffer_size,\n",
    "            batch_size=batch_size,\n",
    "            seed=random_seed,\n",
    "            device=device,\n",
    "        )\n",
    "\n",
    "    def step(self, state, action, reward, next_state, done):\n",
    "        self.memory.add(state, action, reward, next_state, done)\n",
    "\n",
    "        if len(self.memory) > self.batch_size:\n",
    "            experiences = self.memory.sample()\n",
    "            self.learn(experiences, self.gamma)\n",
    "\n",
    "    def act(self, state, add_noise=True):\n",
    "        self.actor_local.eval()\n",
    "        with torch.no_grad():\n",
    "            action = self.actor_local(state).cpu().data.numpy()\n",
    "        self.actor_local.train()\n",
    "        if add_noise:\n",
    "            action += self.noise.sample()\n",
    "        return np.clip(action, -1, 1)\n",
    "\n",
    "    def reset(self):\n",
    "        self.noise.reset()\n",
    "\n",
    "    def learn(self, experiences, gamma):\n",
    "        states, actions, rewards, next_states, dones = experiences\n",
    "\n",
    "        actions_next = self.actor_target(next_states)\n",
    "        Q_targets_next = self.critic_target(next_states, actions_next)\n",
    "        Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n",
    "\n",
    "        Q_expected = self.critic_local(states, actions)\n",
    "        critic_loss = F.mse_loss(Q_expected, Q_targets)\n",
    "\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1)\n",
    "        self.critic_optimizer.step()\n",
    "\n",
    "        actions_pred = self.actor_local(states)\n",
    "        actor_loss = -self.critic_local(states, actions_pred).mean()\n",
    "\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "\n",
    "        self.soft_update(self.critic_local, self.critic_target, self.tau)\n",
    "        self.soft_update(self.actor_local, self.actor_target, self.tau)\n",
    "\n",
    "    def soft_update(self, local_model, target_model, tau):\n",
    "        for target_param, local_param in zip(\n",
    "            target_model.parameters(), local_model.parameters()\n",
    "        ):\n",
    "            target_param.data.copy_(\n",
    "                tau * local_param.data + (1.0 - tau) * target_param.data\n",
    "            )\n",
    "\n",
    "\n",
    "class OUNoise:\n",
    "    \"\"\"Ornstein-Uhlenbeck process.\"\"\"\n",
    "\n",
    "    def __init__(self, size, seed, mu=0.0, theta=0.15, sigma=0.2):\n",
    "        self.size = size\n",
    "        self.mu = mu * np.ones(size)\n",
    "        self.theta = theta\n",
    "        self.sigma = sigma\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.state = copy.copy(self.mu)\n",
    "\n",
    "    def sample(self):\n",
    "        x = self.state\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.random.standard_normal(\n",
    "            self.size\n",
    "        )\n",
    "        self.state = x + dx\n",
    "        return self.state\n",
    "\n",
    "\n",
    "class ReplayBuffer:\n",
    "\n",
    "    experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
    "    \n",
    "    def __init__(self, action_size, buffer_size, batch_size, seed, device=\"cpu\"):\n",
    "        self.action_size = action_size\n",
    "        self.memory = deque(maxlen=buffer_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.device = device\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        e = ReplayBuffer.experience(state, action, reward, next_state, done)\n",
    "        self.memory.append(e)\n",
    "\n",
    "    def sample(self):\n",
    "        experiences = random.sample(self.memory, k=self.batch_size)\n",
    "\n",
    "        states = (\n",
    "            torch.from_numpy(np.vstack([e.state for e in experiences if e is not None]))\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "        actions = (\n",
    "            torch.from_numpy(\n",
    "                np.vstack([e.action for e in experiences if e is not None])\n",
    "            )\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "        rewards = (\n",
    "            torch.from_numpy(\n",
    "                np.vstack([e.reward for e in experiences if e is not None])\n",
    "            )\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "        next_states = (\n",
    "            torch.from_numpy(\n",
    "                np.vstack([e.next_state for e in experiences if e is not None])\n",
    "            )\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "        dones = (\n",
    "            torch.from_numpy(\n",
    "                np.vstack([e.done for e in experiences if e is not None]).astype(\n",
    "                    np.uint8\n",
    "                )\n",
    "            )\n",
    "            .float()\n",
    "            .to(self.device)\n",
    "        )\n",
    "\n",
    "        return (states, actions, rewards, next_states, dones)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "0586a0fb-83fe-4bd7-8717-160653bb262f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 09:42:57 - INFO - ### Initializing environment...\n",
      "2023-12-26 09:42:57 - INFO - ### Training...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "aa6f72076e1b4227be156fec98b30a38",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Episodes:   0%|          | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-26 09:49:43 - INFO - Episode 100\tAverage Score: -1121.09\n",
      "2023-12-26 09:54:05 - INFO - Episode 200\tAverage Score: -429.88\n",
      "2023-12-26 09:59:26 - INFO - Episode 300\tAverage Score: -325.53\n",
      "2023-12-26 10:03:26 - INFO - Episode 400\tAverage Score: -409.73\n",
      "2023-12-26 10:07:39 - INFO - Episode 500\tAverage Score: -460.16\n",
      "2023-12-26 10:11:34 - INFO - Episode 600\tAverage Score: -535.75\n",
      "2023-12-26 10:15:37 - INFO - Episode 700\tAverage Score: -512.84\n",
      "2023-12-26 10:20:04 - INFO - Episode 800\tAverage Score: -543.53\n",
      "2023-12-26 10:24:02 - INFO - Episode 900\tAverage Score: -600.30\n",
      "2023-12-26 10:28:02 - INFO - Episode 1000\tAverage Score: -564.10\n"
     ]
    }
   ],
   "source": [
    "def train(\n",
    "    num_episodes,\n",
    "    max_steps_ep,\n",
    "    seed,\n",
    "    save_every_nth,\n",
    "    log_every_nth,\n",
    "    filepath_checkpoint,\n",
    "    buffer_size,\n",
    "    batch_size,\n",
    "    gamma,\n",
    "    tau,\n",
    "    stepsize_actor,\n",
    "    stepsize_critic,\n",
    "    weight_decay,\n",
    "    logger,\n",
    "    device,\n",
    "    plot=False,\n",
    "):\n",
    "    logger.info(\"### Initializing environment...\")\n",
    "    env = gym.make(\"Pendulum-v1\")\n",
    "    ob, _ = env.reset(seed=seed)\n",
    "    state_size = env.observation_space.shape[0]\n",
    "    action_size = env.action_space.shape[0]\n",
    "    agent = DDPGAgent(\n",
    "        state_size=state_size,\n",
    "        action_size=action_size,\n",
    "        buffer_size=buffer_size,\n",
    "        batch_size=batch_size,\n",
    "        gamma=gamma,\n",
    "        tau=tau,\n",
    "        step_size_actor=stepsize_actor,\n",
    "        step_size_critic=stepsize_critic,\n",
    "        weight_decay=weight_decay,\n",
    "        random_seed=seed,\n",
    "        device=device,\n",
    "    )\n",
    "    \n",
    "    Path(filepath_checkpoint).mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "    logger.info(\"### Training...\")\n",
    "\n",
    "    scores_deque = deque(maxlen=100)\n",
    "    scores = []\n",
    "    scores_avg = []\n",
    "    for i_episode in tqdm(range(1, num_episodes + 1), desc=\"Episodes: \", position=0):\n",
    "        ob, _ = env.reset()\n",
    "        agent.reset()\n",
    "        score = 0\n",
    "        for _ in range(max_steps_ep):\n",
    "            inputs = torch.from_numpy(ob).float().unsqueeze(0).to(device)\n",
    "            action = agent.act(inputs)\n",
    "            action = action[0]\n",
    "            next_ob, reward, terminated, truncated, _ = env.step(action)\n",
    "            done = terminated or truncated\n",
    "            agent.step(ob, action, reward, next_ob, done)\n",
    "            ob = next_ob\n",
    "            score += reward\n",
    "\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        scores_deque.append(score)\n",
    "        scores.append(score)\n",
    "        avg_reward = np.mean(scores_deque)\n",
    "        scores_avg.append(avg_reward)\n",
    "\n",
    "        if i_episode % log_every_nth == 0:\n",
    "            logger.info(\n",
    "                \"Episode {}\\tAverage Score: {:.2f}\".format(\n",
    "                    i_episode, avg_reward\n",
    "                )\n",
    "            )\n",
    "\n",
    "        if i_episode % save_every_nth == 0:\n",
    "            save_checkpoint(\n",
    "                state={\n",
    "                    \"episode\": i_episode,\n",
    "                    \"actor_state_dict\": agent.actor_local.state_dict(),\n",
    "                    \"critic_state_dict\": agent.critic_local.state_dict(),\n",
    "                    \"scores\": scores,\n",
    "                },\n",
    "                filename=f\"{filepath_checkpoint}/checkpoint.pth\",\n",
    "            )\n",
    "            if plot:\n",
    "                plot_scores(\n",
    "                    scores=scores,\n",
    "                    scores_avg=scores_avg,\n",
    "                    fname=f\"{filepath_checkpoint}/avg_scores.png\",\n",
    "                )\n",
    "    return scores, scores_avg\n",
    "\n",
    "scores, scores_avg = train(\n",
    "    num_episodes=NUM_EPISODES,\n",
    "    max_steps_ep=MAX_STEPS_EP,\n",
    "    seed=SEED,\n",
    "    save_every_nth=SAVE_EVERY_NTH,\n",
    "    log_every_nth=LOG_EVERY_STEPS,\n",
    "    filepath_checkpoint=PATH_SAVE_DIR,\n",
    "    buffer_size=BUFFER_SIZE,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    gamma=GAMMA,\n",
    "    tau=TAU,\n",
    "    stepsize_actor=STEP_SIZE_ACTOR,\n",
    "    stepsize_critic=STEP_SIZE_CRITIC,\n",
    "    weight_decay=WEIGHT_DECAY,\n",
    "    logger=logger,\n",
    "    device=DEVICE,\n",
    "    plot=PLOT,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "4f34205f-a39e-4ddf-943c-762666512f40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_scores(scores, scores_avg, show=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "3d3d014e-c3de-4fb1-8976-9ce593d0f925",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/saipiens/src/repos/github/deep-rl-algos-methods/venv/lib/python3.10/site-packages/gymnasium/envs/classic_control/pendulum.py:173: UserWarning: \u001b[33mWARN: You are calling render method without specifying any render mode. You can specify the render_mode at initialization, e.g. gym.make(\"Pendulum-v1\", render_mode=\"rgb_array\")\u001b[0m\n",
      "  gym.logger.warn(\n"
     ]
    }
   ],
   "source": [
    "def test(seed, device, path, render):\n",
    "    env = gym.make(\"Pendulum-v1\", render_mode=\"human\" if render else None)\n",
    "    agent = DDPGAgent(\n",
    "        state_size=env.observation_space.shape[0],\n",
    "        action_size=env.action_space.shape[0],\n",
    "        random_seed=seed,\n",
    "    )\n",
    "\n",
    "    if device == \"cuda\":\n",
    "        checkpoint = torch.load(path)\n",
    "    else:\n",
    "        checkpoint = torch.load(path, map_location=lambda storage, loc: storage)\n",
    "        \n",
    "    agent.actor_local.load_state_dict(checkpoint.get(\"actor_state_dict\"))\n",
    "    agent.critic_local.load_state_dict(checkpoint.get(\"critic_state_dict\"))\n",
    "\n",
    "    ob, _ = env.reset(seed=seed)\n",
    "    agent.reset()\n",
    "    while True:\n",
    "        inputs = torch.from_numpy(ob).float().unsqueeze(0).to(device)\n",
    "        action = agent.act(inputs)\n",
    "        action = action[0]\n",
    "        env.render()\n",
    "        next_ob, _, terminate, truncate, _ = env.step(action)\n",
    "        ob = next_ob\n",
    "        done = terminate | truncate\n",
    "        if done:\n",
    "            break\n",
    "    env.close()\n",
    "\n",
    "test(\n",
    "    seed=SEED,\n",
    "    device=DEVICE,\n",
    "    path=f\"{PATH_SAVE_DIR}/checkpoint.pth\",\n",
    "    render=None,\n",
    ")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}