diff --git "a/rx_rover_DQN.ipynb" "b/rx_rover_DQN.ipynb" new file mode 100644--- /dev/null +++ "b/rx_rover_DQN.ipynb" @@ -0,0 +1,561 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deep Q Network" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import gym\n", + "from gym import spaces\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.patches import Rectangle\n", + "\n", + "import os\n", + "import random\n", + "import imageio\n", + "from tqdm import tqdm \n", + "from itertools import count\n", + "from collections import namedtuple, deque\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class RoverGridEnv(gym.Env):\n", + " metadata={'render.modes': ['human']} \n", + " def __init__(self, max_ts=20): \n", + " super(RoverGridEnv,self).__init__()\n", + " self.max_ts=max_ts # Note: The Max_Timestamps is set to 20 by default.\n", + " self.grid_size=(15,15) \n", + " self.action_space=spaces.Discrete(5) \n", + " self.observation_space=spaces.MultiDiscrete([15,15,15,15,15,15])\n", + " self.rover_positions=np.array([[6,4],[10,4]])\n", + " self.operation_desks=np.array([[6,3],[10,3]])\n", + " self.rooms=np.array([[4,7],[4,10],[4,13],[8,7],[8,10],[8,13],[12,7],[12,10],[12,13]])\n", + " self.human_position=np.array([8,9])\n", + " self.targets=np.array([[5,10],[9,13]])\n", + " self.actions=[(0,-1),(0,1),(-1,0),(1,0),(0,0)] # Down,Up,Left,Right,Wait\n", + " self.rover_done=[False,False] \n", + " self.reset()\n", + " \n", + " def seed(self,seed=None):\n", + " np.random.seed(seed)\n", + " random.seed(seed)\n", + " \n", + " def reset(self):\n", + " self.current_step=0\n", + " self.rover_positions=np.array([[6,4],[10,4]])\n", + " self.rover_done=[False,False]\n", + " self.human_position=np.array([7,8])\n", + " self.current_step=0\n", + " return self._get_obs()\n", + " \n", + " def _get_obs(self):\n", + " return np.concatenate((self.rover_positions.flatten(),self.human_position))\n", + " \n", + " def step(self,actions):\n", + " rewards=np.zeros(2)\n", + " done=[False,False]\n", + " info={'message': ''} \n", + " for i,action in enumerate(actions):\n", + " if self.rover_done[i]:\n", + " done[i]=True \n", + " continue\n", + " prev_distance=np.linalg.norm(self.targets[i]-self.rover_positions[i])\n", + " if self._is_human_adjacent(self.rover_positions[i]):\n", + " rewards[i] -= 5\n", + " else:\n", + " delta=np.array(self.actions[action])\n", + " new_position=self.rover_positions[i]+delta\n", + " if self._out_of_bounds(new_position):\n", + " rewards[i] -= 15\n", + " continue\n", + " if self._collision(new_position,i):\n", + " rewards[i] -= 15\n", + " continue\n", + " self.rover_positions[i]=new_position\n", + " new_distance=np.linalg.norm(self.targets[i]-new_position)\n", + " if new_distance < prev_distance:\n", + " rewards[i] += 30 \n", + " else:\n", + " rewards[i] -= 20 \n", + " if np.array_equal(new_position,self.targets[i]):\n", + " rewards[i] += 100\n", + " self.rover_done[i]=True \n", + " done[i]=True\n", + "\n", + " # move human randomly\n", + " self._move_human()\n", + " self.current_step += 1\n", + " all_done=all(done) or self.current_step >= self.max_ts\n", + " if all_done and not all(done): # if the maximum number of steps is reached but not all targets were reached\n", + " info['message']='Maximum number of timestamps reached'\n", + " return self._get_obs(),rewards,all_done,info\n", + "\n", + " def _is_human_adjacent(self,position):\n", + " for delta in [(1,1),(1,-1),(-1,1),(-1,-1)]:\n", + " adjacent_position=position+np.array(delta)\n", + " if np.array_equal(adjacent_position,self.human_position):\n", + " return True\n", + " return False\n", + "\n", + " def _out_of_bounds(self,position):\n", + " return not (0 <= position[0] < self.grid_size[0] and 0 <= position[1] < self.grid_size[1])\n", + " \n", + " def _collision(self,new_position,rover_index):\n", + " if any(np.array_equal(new_position,pos) for pos in np.delete(self.rover_positions,rover_index,axis=0)):\n", + " return True # Collision with the other rover\n", + " if any(np.array_equal(new_position,pos) for pos in self.rooms):\n", + " return True # Collision with a room\n", + " if any(np.array_equal(new_position,pos) for pos in self.operation_desks):\n", + " return True # Collision with an operation desk\n", + " if np.array_equal(new_position,self.human_position):\n", + " return True # Collision with the human\n", + " return False\n", + " \n", + " def _move_human(self):\n", + " valid_moves=[move for move in self.actions if not self._out_of_bounds(self.human_position+np.array(move))]\n", + " self.human_position += np.array(valid_moves[np.random.choice(len(valid_moves))])\n", + " \n", + " def render(self,mode='human',save_path=None):\n", + " fig,ax=plt.subplots(figsize=(7,7))\n", + " ax.set_xlim(0,self.grid_size[0])\n", + " ax.set_ylim(0,self.grid_size[1])\n", + " ax.set_xticks(np.arange(0,15,1))\n", + " ax.set_yticks(np.arange(0,15,1))\n", + " ax.grid(which='both')\n", + "\n", + " # draw elements\n", + " for pos in self.rover_positions:\n", + " ax.add_patch(Rectangle((pos[0]-0.5,pos[1]-0.5),1,1,color='blue'))\n", + " for pos in self.operation_desks:\n", + " ax.add_patch(Rectangle((pos[0]-0.5,pos[1]-0.5),1,1,color='darkgreen'))\n", + " for pos in self.rooms:\n", + " ax.add_patch(Rectangle((pos[0]-0.5,pos[1]-0.5),1,1,color='black'))\n", + " ax.add_patch(Rectangle((self.human_position[0]-0.5,self.human_position[1]-0.5),1,1,color='purple'))\n", + " for pos in self.targets:\n", + " ax.add_patch(Rectangle((pos[0]-0.5,pos[1]-0.5),1,1,color='yellow',alpha=0.5))\n", + "\n", + " if save_path is not None:\n", + " plt.savefig(save_path)\n", + " plt.close()\n", + " \n", + " def close(self):\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial Setup\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "env=RoverGridEnv()\n", + "print(\"Initial Setup\")\n", + "observation=env.reset()\n", + "env.render()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DQN" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class roverDQN(nn.Module):\n", + " def __init__(self,input_dim,output_dim):\n", + " super(roverDQN,self).__init__()\n", + " self.net=nn.Sequential(\n", + " nn.Linear(input_dim,256),nn.ReLU(),\n", + " nn.Linear(256,128),nn.ReLU(),\n", + " nn.Linear(128,output_dim)) \n", + " def forward(self,x):\n", + " return self.net(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Transition=namedtuple('Transition',('stt','action','nxt_stt','rwd','done'))\n", + "class ReplayMemory(object):\n", + " def __init__(self,capacity):\n", + " self.memory=deque([],maxlen=capacity)\n", + " def push(self,*args):\n", + " self.memory.append(Transition(*args))\n", + " def sample(self,\n", + " batch_size):\n", + " return random.sample(self.memory,\n", + " batch_size)\n", + " def __len__(self):\n", + " return len(self.memory)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def select_act(stt,policy_net,n_actions,stps_done,eps_begin,eps_end,eps_decay):\n", + " sample=random.random()\n", + " eps_threshold=eps_end+(eps_begin-eps_end)*np.exp(-1.*stps_done/eps_decay)\n", + " stps_done += 1\n", + " if sample>eps_threshold:\n", + " with torch.no_grad():\n", + " return policy_net(stt).max(1)[1].view(1,1),stps_done\n", + " else:\n", + " return torch.tensor([[random.randrange(n_actions)]],dtype=torch.long),stps_done" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def optimize_model(memory,\n", + " policy_net,\n", + " target_net,\n", + " optimizer,\n", + " batch_sizee,\n", + " gma):\n", + " if len(memory) < batch_sizee:\n", + " return\n", + " transitions=memory.sample(batch_sizee)\n", + " batch=Transition(*zip(*transitions))\n", + " not_final_mask=torch.tensor(tuple(map(lambda s: s is not None,\n", + " batch.nxt_stt)),\n", + " dtype=torch.bool)\n", + " not_final_nxt_stt=torch.cat([s for s in batch.nxt_stt\n", + " if s is not None])\n", + " stt_batch=torch.cat(batch.stt)\n", + " act_batch=torch.tensor([list(act) for act in batch.action],dtype=torch.long)\n", + " rwd_batch=torch.cat(batch.rwd)\n", + " stt_act_values=policy_net(stt_batch).gather(1,act_batch)\n", + " nxt_stt_values=torch.zeros(batch_sizee)\n", + " nxt_stt_values[not_final_mask]=target_net(not_final_nxt_stt).max(1)[0].detach()\n", + " nxt_stt_values=nxt_stt_values.view(-1,1)\n", + " expected_stt_act_values=(nxt_stt_values*gma)+rwd_batch\n", + " expected_stt_act_values=expected_stt_act_values.squeeze()\n", + "\n", + " criterion=torch.nn.SmoothL1Loss()\n", + " \n", + " loss=criterion(stt_act_values,\n", + " expected_stt_act_values)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " for param in policy_net.parameters():\n", + " param.grad.data.clamp_(-1,1)\n", + " optimizer.step()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "no_epis=1000\n", + "target_update=10\n", + "batch_sizee=256\n", + "gma=0.9\n", + "learning_r=0.001\n", + "eps_begin=1\n", + "eps_end=0.05\n", + "eps_decay=10000\n", + "stps_done=0\n", + "memory=ReplayMemory(10000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "env=RoverGridEnv(max_ts=30)\n", + "policy_net=roverDQN(env.observation_space.shape[0],\n", + " env.action_space.n).float()\n", + "target_net=roverDQN(env.observation_space.shape[0],\n", + " env.action_space.n).float()\n", + "target_net.load_state_dict(policy_net.state_dict())\n", + "target_net.eval()\n", + "optimizer=optim.Adam(policy_net.parameters(),\n", + " lr=learning_r)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training Episodes: 0%| | 0/1000 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,5))\n", + "plt.plot(episode_rwds_dqn)\n", + "plt.title('Total Rewards per Episode')\n", + "plt.xlabel('Episode')\n", + "plt.ylabel('Total Reward')\n", + "plt.grid(True)\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(10,5))\n", + "plt.plot(epsilon_values)\n", + "plt.title('Epsilon Decay')\n", + "plt.xlabel('Steps')\n", + "plt.ylabel('Epsilon Value')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Kiyo\\AppData\\Local\\Temp\\ipykernel_8936\\3320020114.py:30: DeprecationWarning: Starting with ImageIO v3 the behavior of this function will switch to that of iio.v3.imread. To keep the current behavior (and make this warning disappear) use `import imageio.v2 as imageio` or call `imageio.v2.imread` directly.\n", + " frames = [imageio.imread(path) for path in frames_paths]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 1 evaluated, GIF saved to eval_gifs\\episode_1.gif.\n", + "Episode 2 evaluated, GIF saved to eval_gifs\\episode_2.gif.\n", + "Episode 3 evaluated, GIF saved to eval_gifs\\episode_3.gif.\n", + "Episode 4 evaluated, GIF saved to eval_gifs\\episode_4.gif.\n", + "Episode 5 evaluated, GIF saved to eval_gifs\\episode_5.gif.\n", + "Episode 6 evaluated, GIF saved to eval_gifs\\episode_6.gif.\n", + "Episode 7 evaluated, GIF saved to eval_gifs\\episode_7.gif.\n", + "Episode 8 evaluated, GIF saved to eval_gifs\\episode_8.gif.\n", + "Episode 9 evaluated, GIF saved to eval_gifs\\episode_9.gif.\n", + "Episode 10 evaluated, GIF saved to eval_gifs\\episode_10.gif.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def evaluate_agent(env,\n", + " policy_net,\n", + " num_epis=10,\n", + " output_dir='eval_gifs'):\n", + " if not os.path.exists(output_dir):\n", + " os.makedirs(output_dir)\n", + " epi_rwds_eval_dqn=[] \n", + " for episode in range(num_epis):\n", + " stt=env.reset()\n", + " episode_rwds_dqn=np.zeros((2,))\n", + " frames_paths=[]\n", + " done=False\n", + " timestep=0\n", + " while not done:\n", + " with torch.no_grad():\n", + " state_tensor=torch.tensor([stt],dtype=torch.float)\n", + " action1=policy_net(state_tensor).argmax().item()\n", + " action2=policy_net(state_tensor).argmax().item()\n", + " nxt_stt,rewards,done,_=env.step((action1,action2))\n", + " episode_rwds_dqn += rewards \n", + " stt=nxt_stt\n", + " frame_path=os.path.join(output_dir,f\"episode_{episode+1}_frame_{timestep}.png\")\n", + " env.render(save_path=frame_path) \n", + " frames_paths.append(frame_path) \n", + " timestep += 1\n", + " epi_rwds_eval_dqn.append(episode_rwds_dqn) \n", + " frames=[imageio.imread(path) for path in frames_paths]\n", + " gif_path=os.path.join(output_dir,f\"episode_{episode+1}.gif\")\n", + " imageio.mimsave(gif_path,frames,fps=10) \n", + " for path in frames_paths:\n", + " os.remove(path)\n", + " print(f\"Episode {episode+1} evaluated, GIF saved to {gif_path}.\")\n", + " epi_rwds_eval_dqn=np.array(epi_rwds_eval_dqn) \n", + " plt.figure(figsize=(12,6))\n", + " for agent_index in range(2):\n", + " plt.plot(range(1,num_epis+1),\n", + " epi_rwds_eval_dqn[:,agent_index],\n", + " marker='o',\n", + " label=f'Agent {agent_index+1}')\n", + " plt.title('Total Rewards per Episode for Each Agent')\n", + " plt.xlabel('Episode')\n", + " plt.ylabel('Total Reward')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.savefig(os.path.join(output_dir,'rewards_plot.png'))\n", + " plt.show()\n", + "\n", + "evaluate_agent(env,policy_net,num_epis=10)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}