diff --git "a/rx_rover_A2C.ipynb" "b/rx_rover_A2C.ipynb" new file mode 100644--- /dev/null +++ "b/rx_rover_A2C.ipynb" @@ -0,0 +1,556 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Actor Critic" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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", + "from tqdm import tqdm\n", + "\n", + "import os\n", + "import random\n", + "import imageio\n", + "\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torch.distributions import Categorical" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "class RoverGridEnv(gym.Env):\n", + " metadata={'render.modes': ['human']}\n", + " \n", + " def __init__(self,max_ts=20):\n", + " super(RoverGridEnv,self).__init__()\n", + " self.max_ts=max_ts\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._init_positions()\n", + " self.actions=[(0,-1),(0,1),(-1,0),(1,0),(0,0)]\n", + " self.reset()\n", + "\n", + " def _init_positions(self):\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.rover_done=[False,False]\n", + "\n", + " def reset(self):\n", + " self.current_step=0\n", + " self._init_positions()\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", + " rwds=np.zeros(2)\n", + " dones=[False,False]\n", + " info={'message': ''}\n", + " for i,action in enumerate(actions):\n", + " if self.rover_done[i]:\n", + " dones[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", + " rwds[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", + " rwds[i] -= 15\n", + " continue\n", + " if self._collision(new_position,i):\n", + " rwds[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", + " rwds[i]+=30\n", + " else:\n", + " rwds[i] -= 20\n", + " if np.array_equal(new_position,self.targets[i]):\n", + " rwds[i]+=100\n", + " self.rover_done[i]=True\n", + " dones[i]=True\n", + " self._move_human()\n", + " self.current_step+=1\n", + " all_done=all(dones) or self.current_step >= self.max_ts\n", + " if all_done and not all(dones):\n", + " info['message']='Maximum number of timestamps reached'\n", + " return self._get_obs(),rwds,dones,info\n", + " \n", + " def _is_human_adjacent(self,position):\n", + " for delta in [(1,1),(1,-1),(-1,1),(-1,-1)]:\n", + " if np.array_equal(position+np.array(delta),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\n", + " if any(np.array_equal(new_position,pos) for pos in self.rooms):\n", + " return True\n", + " if any(np.array_equal(new_position,pos) for pos in self.operation_desks):\n", + " return True\n", + " if np.array_equal(new_position,self.human_position):\n", + " return True\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[random.choice(range(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", + " # drawing positions\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", + " else:\n", + " plt.show()\n", + "\n", + " def close(self):\n", + " plt.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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": [ + "# A2C" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class rover_ActorCritic(nn.Module):\n", + " def __init__(self,\n", + " input_dim,\n", + " n_actions):\n", + " super(rover_ActorCritic,self).__init__()\n", + " self.actor=nn.Sequential(\n", + " nn.Linear(input_dim,64),nn.ReLU(),\n", + " nn.Linear(64,n_actions),nn.Softmax(dim=-1))\n", + " self.critic=nn.Sequential(\n", + " nn.Linear(input_dim,64),nn.ReLU(),\n", + " nn.Linear(64,1))\n", + " def forward(self,x):\n", + " return self.actor(x),self.critic(x)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "class A2CAgent:\n", + " def __init__(self,\n", + " env,\n", + " lr_actor=0.001,\n", + " lr_critic=0.001,\n", + " gamma=0.99,\n", + " n_steps=2):\n", + " self.env=env\n", + " self.actor_critic1=rover_ActorCritic(env.observation_space.shape[0],\n", + " env.action_space.n)\n", + " self.actor_critic2=rover_ActorCritic(env.observation_space.shape[0],\n", + " env.action_space.n)\n", + " self.optimizer_actor1=optim.Adam(self.actor_critic1.actor.parameters(),\n", + " lr=lr_actor)\n", + " self.optimizer_critic1=optim.Adam(self.actor_critic1.critic.parameters(),\n", + " lr=lr_critic)\n", + " self.optimizer_actor2=optim.Adam(self.actor_critic2.actor.parameters(),\n", + " lr=lr_actor)\n", + " self.optimizer_critic2=optim.Adam(self.actor_critic2.critic.parameters(),\n", + " lr=lr_critic)\n", + " self.gamma=gamma\n", + " self.n_steps=n_steps\n", + "\n", + " def select_action(self,\n", + " stt,\n", + " actor_critic):\n", + " with torch.no_grad():\n", + " act_probs,_=actor_critic(torch.tensor(stt,\n", + " dtype=torch.float32))\n", + " dist=Categorical(act_probs)\n", + " action=dist.sample()\n", + " log_prob=dist.log_prob(action)\n", + " return action.item(),log_prob.item()\n", + "\n", + " def compute_advantages(self,\n", + " rwds,\n", + " values,\n", + " nxt_values,\n", + " gamma=0.99,\n", + " lambda_=0.95):\n", + " rwds=torch.tensor(rwds,\n", + " dtype=torch.float32)\n", + " values=torch.tensor(values,\n", + " dtype=torch.float32)\n", + " nxt_values=torch.tensor(nxt_values,\n", + " dtype=torch.float32)\n", + " deltas=rwds+gamma*nxt_values-values\n", + " advt=torch.zeros_like(deltas)\n", + " for i in reversed(range(len(deltas))):\n", + " advt[i]=deltas[i]+gamma*lambda_*(advt[i+1] if i+1 < len(advt) else 0)\n", + " return advt\n", + "\n", + " def update(self,\n", + " actor_critic,\n", + " optimizer_actor,\n", + " optimizer_critic,\n", + " stts,\n", + " actions,\n", + " rwds,dones,\n", + " next_states):\n", + " stts=torch.tensor(stts,\n", + " dtype=torch.float32)\n", + " actions=torch.tensor(actions,\n", + " dtype=torch.int64)\n", + " rwds=torch.tensor(rwds,\n", + " dtype=torch.float32)\n", + " dones=torch.tensor(dones,\n", + " dtype=torch.float32)\n", + " next_states=torch.tensor(next_states,\n", + " dtype=torch.float32)\n", + " _,critic_values=actor_critic(stts)\n", + " _,next_critic_values=actor_critic(next_states)\n", + " advt=self.compute_advantages(rwds,\n", + " critic_values,\n", + " next_critic_values,\n", + " self.gamma)\n", + " td_targets=rwds+self.gamma*(1-dones)*next_critic_values\n", + " act_probs,_=actor_critic(stts)\n", + " dist=Categorical(act_probs)\n", + " log_probs=dist.log_prob(actions)\n", + "\n", + " a_loss=-(log_probs*advt).mean()\n", + " c_loss=nn.MSELoss()(critic_values.squeeze(),\n", + " td_targets)\n", + " entropy_bonus=-dist.entropy().mean()*0.01\n", + " a_loss+=entropy_bonus\n", + " optimizer_actor.zero_grad()\n", + " optimizer_critic.zero_grad()\n", + " a_loss.backward(retain_graph=True)\n", + " c_loss.backward()\n", + " torch.nn.utils.clip_grad_norm_(actor_critic.parameters(),0.2)\n", + " optimizer_actor.step()\n", + " optimizer_critic.step()\n", + "\n", + " def train(self,num_episodes):\n", + " episode_rewards=[]\n", + " with tqdm(total=num_episodes,desc=\"Training Episodes\") as pbar:\n", + " for _ in range(num_episodes):\n", + " stt=self.env.reset()\n", + " total_episode_reward=0\n", + " while True:\n", + " states1,actions1,rewards1,dones1,next_states1=[],[],[],[],[]\n", + " states2,actions2,rewards2,dones2,next_states2=[],[],[],[],[]\n", + "\n", + " for _ in range(self.n_steps):\n", + " action1,_=self.select_action(stt,self.actor_critic1)\n", + " action2,_=self.select_action(stt,self.actor_critic2)\n", + " next_state,reward,done,_=self.env.step([action1,action2])\n", + " total_episode_reward+=sum(reward)\n", + "\n", + " states1.append(stt)\n", + " actions1.append(action1)\n", + " rewards1.append(reward[0])\n", + " dones1.append(done[0])\n", + " next_states1.append(next_state)\n", + "\n", + " states2.append(stt)\n", + " actions2.append(action2)\n", + " rewards2.append(reward[1])\n", + " dones2.append(done[1])\n", + " next_states2.append(next_state)\n", + " stt=next_state\n", + " if any(done):\n", + " break\n", + "\n", + " self.update(self.actor_critic1,\n", + " self.optimizer_actor1,\n", + " self.optimizer_critic1,\n", + " states1,\n", + " actions1,\n", + " rewards1,\n", + " dones1,\n", + " next_states1)\n", + " self.update(self.actor_critic2,\n", + " self.optimizer_actor2,\n", + " self.optimizer_critic2,\n", + " states2,\n", + " actions2,\n", + " rewards2,\n", + " dones2,\n", + " next_states2)\n", + " if self.env.current_step >= self.env.max_ts or any(done):\n", + " episode_rewards.append(total_episode_reward)\n", + " pbar.set_postfix({'Reward': total_episode_reward})\n", + " pbar.update(1)\n", + " break\n", + " return episode_rewards" + ] + }, + { + "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" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "plt.plot(episode_rewards)\n", + "plt.title(\"Episode Rewards\")\n", + "plt.xlabel(\"Episode\")\n", + "plt.ylabel(\"Total Reward\")\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def moving_average(data,\n", + " window_size=5):\n", + " cum_sum=np.cumsum(np.insert(data,0,0))\n", + " return (cum_sum[window_size:]-cum_sum[:-window_size])/window_size\n", + "\n", + "rewards_moving_avg=moving_average(episode_rewards)\n", + "plt.figure(figsize=(10,6))\n", + "plt.plot(rewards_moving_avg,label=\"Moving Average (window=20)\",linewidth=2)\n", + "plt.title(\"Episode Rewards with Moving Average\")\n", + "plt.xlabel(\"Episode\")\n", + "plt.ylabel(\"Total Reward\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Episode 0: Agent 1 Reward: 320.0,Agent 2 Reward: 245.0\n", + "Episode 1: Agent 1 Reward: 390.0,Agent 2 Reward: 245.0\n", + "Episode 2: Agent 1 Reward: 315.0,Agent 2 Reward: 250.0\n", + "Episode 3: Agent 1 Reward: 310.0,Agent 2 Reward: 210.0\n", + "Episode 4: Agent 1 Reward: 315.0,Agent 2 Reward: 250.0\n", + "Episode 5: Agent 1 Reward: 310.0,Agent 2 Reward: 210.0\n", + "Episode 6: Agent 1 Reward: 270.0,Agent 2 Reward: 230.0\n", + "Episode 7: Agent 1 Reward: 390.0,Agent 2 Reward: 25.0\n", + "Episode 8: Agent 1 Reward: 295.0,Agent 2 Reward: 265.0\n", + "Episode 9: Agent 1 Reward: 350.0,Agent 2 Reward: 185.0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def evaluate_agents(env,actor_critic1,actor_critic2,num_episodes=10):\n", + " rewards_agent1=[]\n", + " rewards_agent2=[]\n", + "\n", + " for episode in range(num_episodes):\n", + " stt=env.reset()\n", + " total_reward1=0\n", + " total_reward2=0\n", + "\n", + " for step in range(env.max_ts):\n", + " state_tensor=torch.tensor(stt,dtype=torch.float32).unsqueeze(0)\n", + " action_probs1,_=actor_critic1(state_tensor)\n", + " action_probs2,_=actor_critic2(state_tensor)\n", + " action1=Categorical(action_probs1).sample().item()\n", + " action2=Categorical(action_probs2).sample().item()\n", + " next_state,rwds,done,_=env.step([action1,action2])\n", + " total_reward1+=rwds[0]\n", + " total_reward2+=rwds[1]\n", + " stt=next_state\n", + " if any(done):\n", + " break\n", + "\n", + " rewards_agent1.append(total_reward1)\n", + " rewards_agent2.append(total_reward2)\n", + " print(f\"Episode {episode}: Agent 1 Reward: {total_reward1},Agent 2 Reward: {total_reward2}\")\n", + "\n", + " plt.figure(figsize=(10,6))\n", + " plt.plot(rewards_agent1,label=\"Agent 1 rwds\")\n", + " plt.plot(rewards_agent2,label=\"Agent 2 rwds\")\n", + " plt.title(\"Evaluation rwds\")\n", + " plt.xlabel(\"Episode\")\n", + " plt.ylabel(\"Total Reward\")\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + "env=RoverGridEnv(max_ts=30)\n", + "evaluate_agents(env,agent.actor_critic1,agent.actor_critic2,num_episodes=10)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}