reinforcement_q_learning_clear.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "device: cuda\n"
     ]
    }
   ],
   "source": [
    "import gymnasium as gym\n",
    "import math\n",
    "import random\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import namedtuple, deque\n",
    "from itertools import count\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "env = gym.make(\"CartPole-v1\")\n",
    "\n",
    "# set up matplotlib\n",
    "is_ipython = 'inline' in matplotlib.get_backend()\n",
    "if is_ipython:\n",
    "    from IPython import display\n",
    "\n",
    "plt.ion()\n",
    "\n",
    "# if GPU is to be used\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print('device:', device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = gym.make(\"CartPole-v1\")\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "Transition = namedtuple('Transition',\n",
    "                        ('state', 'action', 'next_state', 'reward'))\n",
    "\n",
    "\n",
    "# class ReplayMemory(object):\n",
    "\n",
    "#     def __init__(self, capacity):\n",
    "#         self.memory = deque([], maxlen=capacity)\n",
    "\n",
    "#     def push(self, *args):\n",
    "#         \"\"\"Save a transition\"\"\"\n",
    "#         self.memory.append(Transition(*args))\n",
    "\n",
    "#     def sample(self, batch_size):\n",
    "#         return random.sample(self.memory, batch_size)\n",
    "\n",
    "#     def __len__(self):\n",
    "#         return len(self.memory)\n",
    "    \n",
    "import numpy as np\n",
    "\n",
    "class PrioritizedReplayMemory(object):\n",
    "    def __init__(self, capacity, alpha=0.6):\n",
    "        self.alpha = alpha\n",
    "        self.capacity = capacity\n",
    "        self.memory = []\n",
    "        self.priorities = np.zeros((capacity,), dtype=np.float32)\n",
    "        self.position = 0\n",
    "\n",
    "    def push(self, *args):\n",
    "        max_priority = self.priorities.max() if self.memory else 1.0\n",
    "        if len(self.memory) < self.capacity:\n",
    "            self.memory.append(Transition(*args))\n",
    "        else:\n",
    "            self.memory[self.position] = Transition(*args)\n",
    "        self.priorities[self.position] = max_priority\n",
    "        self.position = (self.position + 1) % self.capacity\n",
    "\n",
    "    def sample(self, batch_size, beta=0.4):\n",
    "        if len(self.memory) == self.capacity:\n",
    "            priorities = self.priorities\n",
    "        else:\n",
    "            priorities = self.priorities[:self.position]\n",
    "        probabilities = priorities ** self.alpha\n",
    "        probabilities /= probabilities.sum()\n",
    "\n",
    "        indices = np.random.choice(len(self.memory), batch_size, p=probabilities)\n",
    "        transitions = [self.memory[idx] for idx in indices]\n",
    "\n",
    "        total = len(self.memory)\n",
    "        weights = (total * probabilities[indices]) ** (-beta)\n",
    "        weights /= weights.max()\n",
    "        weights = torch.tensor(weights, device=device, dtype=torch.float32)\n",
    "\n",
    "        batch = Transition(*zip(*transitions))\n",
    "        return batch, weights, indices\n",
    "\n",
    "    def update_priorities(self, batch_indices, batch_priorities):\n",
    "        for idx, priority in zip(batch_indices, batch_priorities):\n",
    "            self.priorities[idx] = priority\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.memory)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQN(nn.Module):\n",
    "    def __init__(self, n_observations, n_actions):\n",
    "        super(DQN, self).__init__()\n",
    "        self.layer1 = nn.Linear(n_observations, 128)\n",
    "        self.layer2 = nn.Linear(128, 256)\n",
    "        self.layer3 = nn.Linear(256, 128)\n",
    "        self.layer4 = nn.Linear(128, n_actions)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.layer1(x))\n",
    "        x = F.relu(self.layer2(x))\n",
    "        x = F.relu(self.layer3(x))\n",
    "        return self.layer4(x)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 128\n",
    "GAMMA = 0.99\n",
    "EPS_START = 0.9\n",
    "EPS_END = 0.05\n",
    "EPS_DECAY = 1000\n",
    "TAU = 0.005\n",
    "LR = 1e-4\n",
    "n_actions = env.action_space.n\n",
    "state, info = env.reset()\n",
    "n_observations = len(state)\n",
    "policy_net = DQN(n_observations, n_actions).to(device)\n",
    "target_net = DQN(n_observations, n_actions).to(device)\n",
    "target_net.load_state_dict(policy_net.state_dict())\n",
    "# optimizer = optim.AdamW(policy_net.parameters(), lr=LR, amsgrad=True)\n",
    "optimizer = optim.RMSprop(policy_net.parameters(), lr=LR)\n",
    "# memory = ReplayMemory(10000)\n",
    "memory = PrioritizedReplayMemory(10000)\n",
    "steps_done = 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "episode_durations = []\n",
    "\n",
    "\n",
    "def plot_durations(show_result=False):\n",
    "    plt.figure(1)\n",
    "    durations_t = torch.tensor(episode_durations, dtype=torch.float)\n",
    "    if show_result:\n",
    "        plt.title('Result')\n",
    "    else:\n",
    "        plt.clf()\n",
    "        plt.title('Training...')\n",
    "    plt.xlabel('Episode')\n",
    "    plt.ylabel('Duration')\n",
    "    plt.plot(durations_t.numpy())\n",
    "    # Take 100 episode averages and plot them too\n",
    "    if len(durations_t) >= 100:\n",
    "        means = durations_t.unfold(0, 100, 1).mean(1).view(-1)\n",
    "        means = torch.cat((torch.zeros(99), means))\n",
    "        plt.plot(means.numpy())\n",
    "\n",
    "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
    "    if is_ipython:\n",
    "        if not show_result:\n",
    "            display.display(plt.gcf())\n",
    "            display.clear_output(wait=True)\n",
    "        else:\n",
    "            display.display(plt.gcf())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_action(state):\n",
    "    global steps_done\n",
    "    eps_threshold = EPS_END + (EPS_START - EPS_END) * max(0.0, (EPS_DECAY - steps_done) / EPS_DECAY)\n",
    "    steps_done += 1\n",
    "    if random.random() > eps_threshold:\n",
    "        with torch.no_grad():\n",
    "            return policy_net(state).max(1).indices.view(1, 1)\n",
    "    else:\n",
    "        return torch.tensor([[env.action_space.sample()]], device=device, dtype=torch.long)\n",
    "\n",
    "def optimize_model():\n",
    "    if len(memory) < BATCH_SIZE:\n",
    "        return\n",
    "    batch, weights, indices = memory.sample(BATCH_SIZE)\n",
    "    \n",
    "    # Compute a mask of non-final states and concatenate the batch elements\n",
    "    non_final_mask = torch.tensor(tuple(map(lambda s: s is not None, batch.next_state)), device=device, dtype=torch.bool)\n",
    "    non_final_next_states = torch.cat([s for s in batch.next_state if s is not None])\n",
    "    state_batch = torch.cat(batch.state)\n",
    "    action_batch = torch.cat(batch.action)\n",
    "    reward_batch = torch.cat(batch.reward)\n",
    "    \n",
    "    # Compute Q(s_t, a)\n",
    "    state_action_values = policy_net(state_batch).gather(1, action_batch)\n",
    "    \n",
    "    # Compute V(s_{t+1}) for all next states\n",
    "    next_state_values = torch.zeros(BATCH_SIZE, device=device)\n",
    "    with torch.no_grad():\n",
    "        next_state_values[non_final_mask] = target_net(non_final_next_states).max(1).values\n",
    "    expected_state_action_values = (next_state_values * GAMMA) + reward_batch\n",
    "\n",
    "    # Compute Huber loss\n",
    "    criterion = nn.SmoothL1Loss(reduction='none')\n",
    "    loss = criterion(state_action_values, expected_state_action_values.unsqueeze(1))\n",
    "    prios = loss + 1e-5\n",
    "    loss = (loss * weights.unsqueeze(1)).mean()\n",
    "\n",
    "    # Optimize the model\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    torch.nn.utils.clip_grad_value_(policy_net.parameters(), 100)\n",
    "    optimizer.step()\n",
    "\n",
    "    memory.update_priorities(indices, prios.detach().cpu().numpy())\n",
    "\n",
    "def optimize_reward(state, reward, done):\n",
    "    x, x_dot, theta, theta_dot = state\n",
    "    r1 = (env.env.x_threshold - abs(x)) / env.env.x_threshold - 0.8\n",
    "    r2 = (env.env.theta_threshold_radians - abs(theta)) / env.env.theta_threshold_radians - 0.5\n",
    "    reward = r1 + r2\n",
    "    if done:\n",
    "        reward -= 10\n",
    "    return reward\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 55, Cumulative Reward: 217.83108779885777, success_count: 10\n",
      "Complete\n",
      "The training time is  59.967573165893555 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    num_episodes = 600\n",
    "else:\n",
    "    num_episodes = 500\n",
    "\n",
    "import time\n",
    "start_time = time.time()\n",
    "\n",
    "success_count = 0  # 记录连续成功达到500步的次数\n",
    "\n",
    "for i_episode in range(num_episodes):\n",
    "    # Initialize the environment and get its state\n",
    "    state, info = env.reset()\n",
    "    state = torch.tensor(state, dtype=torch.float32, device=device).unsqueeze(0)\n",
    "    cumulative_reward = 0\n",
    "    for t in count():\n",
    "        action = select_action(state)\n",
    "        observation, reward, terminated, truncated, _ = env.step(action.item())\n",
    "\n",
    "        reward = optimize_reward(observation, reward, terminated)\n",
    "        cumulative_reward += reward\n",
    "        reward = torch.tensor([reward], device=device)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        if terminated:\n",
    "            next_state = None\n",
    "        else:\n",
    "            next_state = torch.tensor(observation, dtype=torch.float32, device=device).unsqueeze(0)\n",
    "        # Store the transition in memory\n",
    "        memory.push(state, action, next_state, reward)\n",
    "        \n",
    "        state = next_state\n",
    "        \n",
    "        optimize_model()\n",
    "        \n",
    "        target_net_state_dict = target_net.state_dict()\n",
    "        policy_net_state_dict = policy_net.state_dict()\n",
    "        for key in policy_net_state_dict:\n",
    "            target_net_state_dict[key] = policy_net_state_dict[key] * TAU + target_net_state_dict[key] * (1 - TAU)\n",
    "        target_net.load_state_dict(target_net_state_dict)\n",
    "        if done:\n",
    "            episode_durations.append(t + 1)\n",
    "            plot_durations()\n",
    "            if truncated:\n",
    "                success_count += 1\n",
    "            else:\n",
    "                success_count = 0\n",
    "            break\n",
    "    print(f'Episode {i_episode + 1}, Cumulative Reward: {cumulative_reward}, success_count: {success_count}')\n",
    "    if success_count >= 10:\n",
    "        break\n",
    "\n",
    "end_time = time.time()\n",
    "print('Complete')\n",
    "print('The training time is ', (end_time - start_time), 's')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_durations(show_result=True)\n",
    "plt.ioff()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ai_lab",
   "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.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}