Aula3_DQN_LunarLander.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "c3e89aca-6c52-4b20-b1a3-9279ef0fd99b",
      "metadata": {
        "id": "c3e89aca-6c52-4b20-b1a3-9279ef0fd99b"
      },
      "source": [
        "# Aula 3 - Reinforcement Learning\n",
        "\n",
        "# Deep Q-Network (DQN) no LunarLander-v2\n",
        "\n",
        "### Prof. Dr. Ahirton Lopes (profahirton.lopes@fiap.com.br)\n",
        "\n",
        "> Neste exemplo, faremos um laboratório prático de Simple Deep Q-Network (DQN) no ambiente openAI LunarLander-v3. Este é um exercício de codificação originalmente encontrado no Nanodegree Deep Reinforcement Learning da Udacity.\n",
        "\n",
        "- toc: verdadeiro\n",
        "- emblemas: verdadeiro\n",
        "- comentários: verdadeiro\n",
        "-autor: Chanseok Kang\n",
        "- categorias: [Python, Reinforcement_Learning, PyTorch, Udacity]\n",
        "\n",
        "\n",
        "![texto alternativo](https://gymnasium.farama.org/_images/lunar_lander.gif)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fd834f1b-51c4-4910-a4d6-3b212e1a2a5a",
      "metadata": {
        "id": "fd834f1b-51c4-4910-a4d6-3b212e1a2a5a"
      },
      "source": [
        "## Rede Q Profunda (DQN)\n",
        "---\n",
        "Neste notebook, você implementará um agente DQN com o ambiente LunarLander-v2 do OpenAI Gym.\n",
        "\n",
        "### Importe os pacotes necessários"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install swig\n",
        "!pip install gymnasium[box2d]"
      ],
      "metadata": {
        "id": "KGwge0VNvRSo",
        "outputId": "3e99acff-ae63-4a28-e8aa-d7d7daa2bd80",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "id": "KGwge0VNvRSo",
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: swig in /usr/local/lib/python3.11/dist-packages (4.3.0)\n",
            "Requirement already satisfied: gymnasium[box2d] in /usr/local/lib/python3.11/dist-packages (1.0.0)\n",
            "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.11/dist-packages (from gymnasium[box2d]) (1.26.4)\n",
            "Requirement already satisfied: cloudpickle>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from gymnasium[box2d]) (3.1.1)\n",
            "Requirement already satisfied: typing-extensions>=4.3.0 in /usr/local/lib/python3.11/dist-packages (from gymnasium[box2d]) (4.12.2)\n",
            "Requirement already satisfied: farama-notifications>=0.0.1 in /usr/local/lib/python3.11/dist-packages (from gymnasium[box2d]) (0.0.4)\n",
            "Requirement already satisfied: box2d-py==2.3.5 in /usr/local/lib/python3.11/dist-packages (from gymnasium[box2d]) (2.3.5)\n",
            "Requirement already satisfied: pygame>=2.1.3 in /usr/local/lib/python3.11/dist-packages (from gymnasium[box2d]) (2.6.1)\n",
            "Requirement already satisfied: swig==4.* in /usr/local/lib/python3.11/dist-packages (from gymnasium[box2d]) (4.3.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "id": "22518486-3c2f-47fe-92b3-1502875eacfe",
      "metadata": {
        "id": "22518486-3c2f-47fe-92b3-1502875eacfe"
      },
      "outputs": [],
      "source": [
        "import gymnasium as gym\n",
        "import random\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import matplotlib.pyplot as plt\n",
        "import base64, io\n",
        "\n",
        "import numpy as np\n",
        "from collections import deque, namedtuple\n",
        "\n",
        "# For visualization\n",
        "from gym.wrappers.monitoring import video_recorder\n",
        "from IPython.display import HTML\n",
        "from IPython import display\n",
        "import glob"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "f75f934c-6921-43aa-8389-6df4b993eca4",
      "metadata": {
        "id": "f75f934c-6921-43aa-8389-6df4b993eca4"
      },
      "source": [
        "### Instanciar o ambiente e o agente\n",
        "\n",
        "Inicialize o ambiente."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "id": "594828b6-da33-481d-ab42-041e8c17ffea",
      "metadata": {
        "id": "594828b6-da33-481d-ab42-041e8c17ffea",
        "outputId": "fabea1fa-f586-44ca-aba1-25e01f2e6588",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "State shape:  (8,)\n",
            "Number of actions:  4\n"
          ]
        }
      ],
      "source": [
        "env = gym.make('LunarLander-v3')\n",
        "print('State shape: ', env.observation_space.shape)\n",
        "print('Number of actions: ', env.action_space.n)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "03735bdc-c07e-4c87-b208-cce894bb8e43",
      "metadata": {
        "id": "03735bdc-c07e-4c87-b208-cce894bb8e43"
      },
      "source": [
        "### Definir arquitetura de rede neural.\n",
        "\n",
        "Como o ambiente `LunarLander-v2` é uma espécie de ambiente simples, não precisamos de arquitetura complicada. Precisamos apenas de um aproximador de função não linear que mapeie do estado para a ação."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "id": "ae834607-433e-4ed5-8b23-8de7b53230a8",
      "metadata": {
        "id": "ae834607-433e-4ed5-8b23-8de7b53230a8"
      },
      "outputs": [],
      "source": [
        "class QNetwork(nn.Module):\n",
        "    \"\"\"Actor (Policy) Model.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed):\n",
        "        \"\"\"Initialize parameters and build model.\n",
        "        Params\n",
        "        ======\n",
        "            state_size (int): Dimension of each state\n",
        "            action_size (int): Dimension of each action\n",
        "            seed (int): Random seed\n",
        "        \"\"\"\n",
        "        super(QNetwork, self).__init__()\n",
        "        self.seed = torch.manual_seed(seed)\n",
        "        self.fc1 = nn.Linear(state_size, 64)\n",
        "        self.fc2 = nn.Linear(64, 64)\n",
        "        self.fc3 = nn.Linear(64, action_size)\n",
        "\n",
        "    def forward(self, state):\n",
        "        \"\"\"Build a network that maps state -> action values.\"\"\"\n",
        "        x = self.fc1(state)\n",
        "        x = F.relu(x)\n",
        "        x = self.fc2(x)\n",
        "        x = F.relu(x)\n",
        "        return self.fc3(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "b0873298-cab0-4dcb-9c84-4782dc914dd7",
      "metadata": {
        "id": "b0873298-cab0-4dcb-9c84-4782dc914dd7"
      },
      "source": [
        "### Definindo alguns hiperparâmetros"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "id": "7010c525-29d8-445c-8769-6cfb7d00948b",
      "metadata": {
        "id": "7010c525-29d8-445c-8769-6cfb7d00948b"
      },
      "outputs": [],
      "source": [
        "BUFFER_SIZE = int(1e5)  # replay buffer size\n",
        "BATCH_SIZE = 64         # minibatch size\n",
        "GAMMA = 0.99            # discount factor\n",
        "TAU = 1e-3              # for soft update of target parameters\n",
        "LR = 5e-4               # learning rate\n",
        "UPDATE_EVERY = 4        # how often to update the network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "id": "334bb7d8-7d62-4cfb-96f7-f8809ba8e089",
      "metadata": {
        "id": "334bb7d8-7d62-4cfb-96f7-f8809ba8e089"
      },
      "outputs": [],
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1d861efe-200c-4690-9698-722abbf0b77c",
      "metadata": {
        "id": "1d861efe-200c-4690-9698-722abbf0b77c"
      },
      "source": [
        "### Definindo o Agente"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "id": "0530f456-2bfd-4061-ad62-f14846a9a284",
      "metadata": {
        "id": "0530f456-2bfd-4061-ad62-f14846a9a284"
      },
      "outputs": [],
      "source": [
        "class Agent():\n",
        "    \"\"\"Interacts with and learns from the environment.\"\"\"\n",
        "\n",
        "    def __init__(self, state_size, action_size, seed):\n",
        "        \"\"\"Initialize an Agent object.\n",
        "\n",
        "        Params\n",
        "        ======\n",
        "            state_size (int): dimension of each state\n",
        "            action_size (int): dimension of each action\n",
        "            seed (int): random seed\n",
        "        \"\"\"\n",
        "        self.state_size = state_size\n",
        "        self.action_size = action_size\n",
        "        self.seed = random.seed(seed)\n",
        "\n",
        "        # Q-Network\n",
        "        self.qnetwork_local = QNetwork(state_size, action_size, seed).to(device)\n",
        "        self.qnetwork_target = QNetwork(state_size, action_size, seed).to(device)\n",
        "        self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=LR)\n",
        "\n",
        "        # Replay memory\n",
        "        self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)\n",
        "        # Initialize time step (for updating every UPDATE_EVERY steps)\n",
        "        self.t_step = 0\n",
        "\n",
        "    def step(self, state, action, reward, next_state, done):\n",
        "        # Save experience in replay memory\n",
        "        self.memory.add(state, action, reward, next_state, done)\n",
        "\n",
        "        # Learn every UPDATE_EVERY time steps.\n",
        "        self.t_step = (self.t_step + 1) % UPDATE_EVERY\n",
        "        if self.t_step == 0:\n",
        "            # If enough samples are available in memory, get random subset and learn\n",
        "            if len(self.memory) > BATCH_SIZE:\n",
        "                experiences = self.memory.sample()\n",
        "                self.learn(experiences, GAMMA)\n",
        "\n",
        "    def act(self, state, eps=0.):\n",
        "        \"\"\"Returns actions for given state as per current policy.\n",
        "\n",
        "        Params\n",
        "        ======\n",
        "            state (array_like): current state\n",
        "            eps (float): epsilon, for epsilon-greedy action selection\n",
        "        \"\"\"\n",
        "        state = torch.from_numpy(state).float().unsqueeze(0).to(device)\n",
        "        self.qnetwork_local.eval()\n",
        "        with torch.no_grad():\n",
        "            action_values = self.qnetwork_local(state)\n",
        "        self.qnetwork_local.train()\n",
        "\n",
        "        # Epsilon-greedy action selection\n",
        "        if random.random() > eps:\n",
        "            return np.argmax(action_values.cpu().data.numpy())\n",
        "        else:\n",
        "            return random.choice(np.arange(self.action_size))\n",
        "\n",
        "    def learn(self, experiences, gamma):\n",
        "        \"\"\"Update value parameters using given batch of experience tuples.\n",
        "\n",
        "        Params\n",
        "        ======\n",
        "            experiences (Tuple[torch.Variable]): tuple of (s, a, r, s', done) tuples\n",
        "            gamma (float): discount factor\n",
        "        \"\"\"\n",
        "        # Obtain random minibatch of tuples from D\n",
        "        states, actions, rewards, next_states, dones = experiences\n",
        "\n",
        "        ## Compute and minimize the loss\n",
        "        ### Extract next maximum estimated value from target network\n",
        "        q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n",
        "        ### Calculate target value from bellman equation\n",
        "        q_targets = rewards + gamma * q_targets_next * (1 - dones)\n",
        "        ### Calculate expected value from local network\n",
        "        q_expected = self.qnetwork_local(states).gather(1, actions)\n",
        "\n",
        "        ### Loss calculation (we used Mean squared error)\n",
        "        loss = F.mse_loss(q_expected, q_targets)\n",
        "        self.optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        self.optimizer.step()\n",
        "\n",
        "        # ------------------- update target network ------------------- #\n",
        "        self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\n",
        "\n",
        "    def soft_update(self, local_model, target_model, tau):\n",
        "        \"\"\"Soft update model parameters.\n",
        "        θ_target = τ*θ_local + (1 - τ)*θ_target\n",
        "\n",
        "        Params\n",
        "        ======\n",
        "            local_model (PyTorch model): weights will be copied from\n",
        "            target_model (PyTorch model): weights will be copied to\n",
        "            tau (float): interpolation parameter\n",
        "        \"\"\"\n",
        "        for target_param, local_param in zip(target_model.parameters(), local_model.parameters()):\n",
        "            target_param.data.copy_(tau*local_param.data + (1.0-tau)*target_param.data)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4eb5db66-ecb3-4bf4-aee1-3e18003c17b0",
      "metadata": {
        "id": "4eb5db66-ecb3-4bf4-aee1-3e18003c17b0"
      },
      "source": [
        "### Definindo o Replay Buffer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "id": "f74bb08e-0b95-42db-9fc8-d609514d55af",
      "metadata": {
        "id": "f74bb08e-0b95-42db-9fc8-d609514d55af"
      },
      "outputs": [],
      "source": [
        "class ReplayBuffer:\n",
        "    \"\"\"Fixed-size buffer to store experience tuples.\"\"\"\n",
        "\n",
        "    def __init__(self, action_size, buffer_size, batch_size, seed):\n",
        "        \"\"\"Initialize a ReplayBuffer object.\n",
        "\n",
        "        Params\n",
        "        ======\n",
        "            action_size (int): dimension of each action\n",
        "            buffer_size (int): maximum size of buffer\n",
        "            batch_size (int): size of each training batch\n",
        "            seed (int): random seed\n",
        "        \"\"\"\n",
        "        self.action_size = action_size\n",
        "        self.memory = deque(maxlen=buffer_size)\n",
        "        self.batch_size = batch_size\n",
        "        self.experience = namedtuple(\"Experience\", field_names=[\"state\", \"action\", \"reward\", \"next_state\", \"done\"])\n",
        "        self.seed = random.seed(seed)\n",
        "\n",
        "    def add(self, state, action, reward, next_state, done):\n",
        "        \"\"\"Add a new experience to memory.\"\"\"\n",
        "        e = self.experience(state, action, reward, next_state, done)\n",
        "        self.memory.append(e)\n",
        "\n",
        "    def sample(self):\n",
        "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
        "        experiences = random.sample(self.memory, k=self.batch_size)\n",
        "\n",
        "        states = torch.from_numpy(np.vstack([e.state for e in experiences if e is not None])).float().to(device)\n",
        "        actions = torch.from_numpy(np.vstack([e.action for e in experiences if e is not None])).long().to(device)\n",
        "        rewards = torch.from_numpy(np.vstack([e.reward for e in experiences if e is not None])).float().to(device)\n",
        "        next_states = torch.from_numpy(np.vstack([e.next_state for e in experiences if e is not None])).float().to(device)\n",
        "        dones = torch.from_numpy(np.vstack([e.done for e in experiences if e is not None]).astype(np.uint8)).float().to(device)\n",
        "\n",
        "        return (states, actions, rewards, next_states, dones)\n",
        "\n",
        "    def __len__(self):\n",
        "        \"\"\"Return the current size of internal memory.\"\"\"\n",
        "        return len(self.memory)"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "6bd61b8d-b63e-444f-9cb7-6295df46995d",
      "metadata": {
        "id": "6bd61b8d-b63e-444f-9cb7-6295df46995d"
      },
      "source": [
        "### Treinamento"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "id": "c907ab57-ed48-4824-b27c-8c7d707d6919",
      "metadata": {
        "id": "c907ab57-ed48-4824-b27c-8c7d707d6919",
        "outputId": "6676e668-e4be-4a5e-d995-09c1ddd99fd4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Episode 100\tAverage Score: -162.90\n",
            "Episode 200\tAverage Score: -111.10\n",
            "Episode 300\tAverage Score: -60.23\n",
            "Episode 400\tAverage Score: -32.28\n",
            "Episode 500\tAverage Score: 57.24\n"
          ]
        }
      ],
      "source": [
        "def dqn(n_episodes=500, max_t=1000, eps_start=1.0, eps_end=0.01, eps_decay=0.995):\n",
        "    \"\"\"Deep Q-Learning.\n",
        "\n",
        "    Params\n",
        "    ======\n",
        "        n_episodes (int): maximum number of training episodes\n",
        "        max_t (int): maximum number of timesteps per episode\n",
        "        eps_start (float): starting value of epsilon, for epsilon-greedy action selection\n",
        "        eps_end (float): minimum value of epsilon\n",
        "        eps_decay (float): multiplicative factor (per episode) for decreasing epsilon\n",
        "    \"\"\"\n",
        "    scores = []                        # list containing scores from each episode\n",
        "    scores_window = deque(maxlen=100)  # last 100 scores\n",
        "    eps = eps_start                    # initialize epsilon\n",
        "    for i_episode in range(1, n_episodes+1):\n",
        "        state = env.reset()            # Handle env.reset()\n",
        "        if isinstance(state, tuple):   # Extract state if reset() returns a tuple\n",
        "            state = state[0]\n",
        "        score = 0\n",
        "        for t in range(max_t):\n",
        "            action = agent.act(state, eps)\n",
        "            step_result = env.step(action)  # Handle env.step(action)\n",
        "            if isinstance(step_result, tuple):\n",
        "                next_state, reward, done = step_result[:3]  # Extract the first three elements\n",
        "            else:\n",
        "                next_state, reward, done = step_result\n",
        "            agent.step(state, action, reward, next_state, done)\n",
        "            state = next_state\n",
        "            score += reward\n",
        "            if done:\n",
        "                break\n",
        "        scores_window.append(score)       # save most recent score\n",
        "        scores.append(score)              # save most recent score\n",
        "        eps = max(eps_end, eps_decay*eps) # decrease epsilon\n",
        "        print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n",
        "        if i_episode % 100 == 0:\n",
        "            print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n",
        "        if np.mean(scores_window) >= 200.0:\n",
        "            print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\n",
        "            torch.save(agent.qnetwork_local.state_dict(), 'checkpoint.pth')\n",
        "            break\n",
        "    return scores\n",
        "\n",
        "agent = Agent(state_size=8, action_size=4, seed=0)\n",
        "scores = dqn()"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "1ba6726a-977a-4345-8897-021302bfc262",
      "metadata": {
        "id": "1ba6726a-977a-4345-8897-021302bfc262"
      },
      "source": [
        "### Plotando o Progresso de Aprendizagem"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "id": "d2d491c9-a5dc-4c32-a95d-796f85c60c83",
      "metadata": {
        "id": "d2d491c9-a5dc-4c32-a95d-796f85c60c83",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 450
        },
        "outputId": "3c32c16b-9d62-4bc3-a442-f862091bdb6a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# plot the scores\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111)\n",
        "plt.plot(np.arange(len(scores)), scores)\n",
        "plt.ylabel('Score')\n",
        "plt.xlabel('Episode #')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A partir do gráfico acima, observamos que, embora a recompensa máxima seja alcançada rapidamente. Conseguir uma recompensa episódica de > 200 é bom. Vemos que o agente conseguiu isso em menos de 500 episódios (a velocidade é boa!). No entanto, existem muitas flutuações no desempenho (a estabilidade não é boa!)."
      ],
      "metadata": {
        "id": "4T7mNBrWBxDp"
      },
      "id": "4T7mNBrWBxDp"
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.7.10"
    },
    "colab": {
      "provenance": [],
      "machine_shape": "hm",
      "gpuType": "T4"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 5
}