Upload 25 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+images/all_algos_testing.png filter=lfs diff=lfs merge=lfs -text
+images/all_algos.png filter=lfs diff=lfs merge=lfs -text
+Report.pdf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,230 @@
----
-license: mit
----
+# RxRovers: Roaming for Rapid Relief
+
+<span style="color: blue;">Dynamic Obstacles and Path Optimization
+
+![Trained Agents in Action](images/trained_agents.gif)
+
+## Project Overview
+
+"RxRovers: Roaming for Rapid Relief" aims to integrate advanced reinforcement learning (RL) into the healthcare domain, specifically focusing on optimizing medical supply delivery within hospital settings. This project seeks to deploy autonomous agents, RxRovers, which are programmed to navigate through hospital corridors efficiently, dodging any potential obstacles (dynamic and static) to ensure the timely distribution of medicines. This innovation can significantly enhance patient care and outcomes.
+
+## Team Members
+
+-   Charvi Kusuma [GitHub](https://github.com/kcharvi)
+-   Tarun Reddi [GitHub](https://github.com/REDDITARUN)
+
+### Real-World Application
+
+The RxRovers project directly addresses a real-world healthcare problem: simulating delivery of medical supplies efficiently within hospital environments. This project integrates RL into the healthcare domain to enhance this delivery system, directly benefiting patient care and outcomes.
+
+### Complex Navigation Challenges
+
+The project’s challenges mirror real-world navigation complexities in hospital settings:
+
+-   **Dynamic and Static Obstacles**: Accurate representation of unpredictable hospital environments.
+-   **Path Planning**: Optimization to ensure timely and efficient delivery of medical supplies.
+
+### Adaptable Environment
+
+The project's environment can be modified to reflect various real-world hospital layouts, demonstrating its adaptability to different healthcare settings.
+
+## Objectives
+
+1. Develop RL agents capable of autonomously navigating hospital environments while delivering medical supplies.
+2. Optimize path planning strategies to ensure timely and efficient delivery of medicines, while avoiding obstacles such as equipment, humans, and environmental constraints.
+3. Enhance the visual representation and user experience of the simulated hospital environment to improve engagement and realism.
+4. Conduct comparative analysis of various reinforcement learning algorithms to identify the optimal approach for medical supply delivery optimization within hospital environments.
+
+## Environment
+
+### Simulated Hospital Layouts
+
+The project creates a hospital environment that mirrors real-world scenarios. The environment includes features such as:
+
+-   **Hospital Corridors**: Multiple corridors, rooms, and operation desks.
+-   **Obstacles**: Dynamic obstacles (humans, other rovers) and static obstacles (rooms, walls).
+-   **RxRovers**: Autonomous agents programmed to navigate these environments, avoid obstacles, and reach designated destinations.
+
+### Initial Stage
+
+-   **Grid**: 9×9 grid simulating rovers navigating on a grid.
+-   **Setup**: Initialized action and observation spaces, set up grid size, starting points, destinations, and parameters such as rewards and penalties for actions and events.
+
+### Refined Version
+
+-   **Grid Size**: 15×15 grid representing the hospital environment.
+-   **Rovers**: Two agents represented by blue squares.
+-   **Targets**: Yellow target destinations for delivering medicine.
+-   **Actions**: Move down, up, left, right, or stay still (5 possible actions).
+-   **Operation Desks**: Dark green squares representing starting points.
+-   **Rooms**: Black squares indicating static obstacles.
+-   **Human**: Purple square representing a moving human obstacle.
+-   **Observation Space**: Positions of the Rovers, human, rooms, operation desks, and the grid boundary.
+-   **Rewards**:
+    -   +30 for moving closer to targets.
+    -   +100 for reaching destinations.
+    -   -15 for collisions or moving out of grid bounds.
+    -   -5 for waiting near the human obstacle.
+    -   -20 for moving away from targets.
+-   **Termination**: Episode ends if both Rovers reach their targets or maximum time steps (20) are reached.
+
+![Environment Image](images/enhanced-environment.png)
+
+## Algorithms
+
+### Q-Learning (QL)
+
+Implemented Q-Learning for a rover agent navigating a grid environment.
+
+-   **Settings**:
+    -   State Representation: Positions of the two rovers and the human.
+    -   Action Space: Move up, down, left, right, or stay in place.
+    -   Rewards: Based on interactions (moving closer to target, collisions, reaching target).
+    -   Done Flag: Episode terminates when both rovers reach targets or max time steps are reached.
+-   **Hyperparameters**:
+    -   Alpha (Learning Rate): 1e-4
+    -   Gamma (Discount Factor): 0.9
+    -   Epsilon (Exploration Rate): 0.5
+    -   Epsilon Decay: 0.995
+    -   Epsilon Minimum: 0.01
+-   **Training Phase**:
+    -   Total Rewards per Episode
+    -   Epsilon Decay Curve
+-   **Evaluation Phase**:
+    -   Evaluation Rewards per Episode
+
+### Double Q-Learning (DQL)
+
+Implemented Double Q-Learning to mitigate overestimation biases.
+
+-   **Settings**: Same as Q-Learning.
+-   **Hyperparameters**: Same as Q-Learning.
+-   **Training Phase**:
+    -   Total Rewards per Episode
+-   **Evaluation Phase**:
+    -   Evaluation Rewards
+
+### Deep Q Network (DQN)
+
+Utilized a neural network to approximate the Q-values.
+
+-   **Settings**:
+    -   Neural Network Architecture: Two hidden layers with ReLU activation.
+    -   Replay Memory: Stores past experiences for experience replay.
+    -   Select Action Function: Epsilon-greedy strategy.
+    -   Optimize Model Function: Gradient descent on the Q-network.
+-   **Hyperparameters**:
+    -   Number of Episodes: 1000
+    -   Target Network Update Frequency: 10 episodes
+    -   Batch Size: 256
+    -   Discount Factor: 0.9
+    -   Learning Rate: 0.001
+    -   Epsilon Initial Value: 1
+    -   Epsilon Final Value: 0.05
+    -   Epsilon Decay: 10000
+    -   Maximum Timestamps per Episode: 30
+-   **Training Phase**:
+    -   Total Rewards per Episode
+    -   Epsilon Decay Curve
+-   **Evaluation Phase**:
+    -   Evaluation Rewards
+
+### Double Deep Q Network (DDQN)
+
+Addresses overestimation bias by decoupling selection and evaluation of the action.
+
+-   **Settings**:
+    -   Optimize Model Function: Gradient descent with gradients clipping.
+-   **Hyperparameters**:
+    -   Batch Size: 256
+    -   Gamma: 0.9
+    -   Learning Rate: 0.001
+    -   Epsilon Start: 1
+    -   Epsilon End: 0.05
+    -   Epsilon Decay: 10,000
+    -   Number of Episodes: 1000
+    -   Target Update: Every 10 episodes
+-   **Training Phase**:
+    -   Total Rewards per Episode
+    -   Epsilon Decay Curve
+-   **Evaluation Phase**:
+    -   Evaluation Rewards
+
+### Proximal Policy Optimization (PPO)
+
+A robust and efficient algorithm developed by OpenAI.
+
+-   **Settings**:
+    -   Neural Network Architecture: Actor and critic heads.
+    -   Training Loop: States, actions, rewards, values, and log-probs collected in replay buffer.
+    -   Loss Functions: Policy and value losses.
+-   **Hyperparameters**:
+    -   Total Timesteps: 50,000
+    -   Gamma: 0.99
+    -   Lambda: 0.95
+    -   Epsilon: 0.2
+    -   Epochs: 3
+    -   Batch Size: 64
+    -   Learning Rate: 0.001
+-   **Training Phase**:
+    -   Total Rewards per Episode
+-   **Evaluation Phase**:
+    -   Evaluation Rewards
+
+### Actor Critic (A2C)
+
+Combines elements of both policy-based methods (Actor) and value-based methods (Critic).
+
+-   **Settings**:
+    -   Actor Network: Learns a policy π(s).
+    -   Critic Network: Learns the value function V(s).
+    -   Advantage: Measures action quality.
+    -   Policy and Value Function Updates: Gradient descent.
+-   **Training Phase**:
+    -   Total Rewards per Episode
+-   **Evaluation Phase**:
+    -   Evaluation Rewards
+
+**Total Rewards Plot during Training:**
+
+![Plots](images/all_algos.png)
+
+**Evaluation for 10 Timestamps:**
+
+![Evaluation Plots](images/all_algos_testing.png)
+
+## Comparison
+
+Comparison of different reinforcement learning algorithms and their performance:
+
+| Aspect                    | Q-Learning              | Double Q-Learning       | DQN                  | DDQN                           | PPO                           | A2C                           |
+| ------------------------- | ----------------------- | ----------------------- | -------------------- | ------------------------------ | ----------------------------- | ----------------------------- |
+| Algorithm Type            | Model-free, Value-based | Model-free, Value-based | Value-based, Deep NN | Value-based, Deep NN           | Actor-Critic, Policy Gradient | Actor-Critic, Policy Gradient |
+| Exploration-Exploitation  | Epsilon-greedy          | Epsilon-greedy          | Epsilon-greedy       | Epsilon-greedy                 | Continuous                    | Continuous                    |
+| Stability & Learning Rate | No target network       | No target network       | Target network       | Double updates, target network | Adaptive, Gradient Clipping   | Adaptive, Entropy Bonus       |
+| Convergence               | Slow                    | Moderate                | Fast                 | Faster                         | Fast                          | Moderate                      |
+| Memory Requirements       | Low                     | Low                     | High                 | High                           | Moderate                      | Moderate                      |
+| Adaptability              | Moderate                | Moderate                | Low to Moderate      | Low to Moderate                | High                          | Moderate                      |
+| Generalization            | Low to Moderate         | Low to Moderate         | Low                  | Low                            | High                          | Moderate                      |
+
+## Challenges Addressed
+
+1. **Navigating a Dynamic World**: Rovers learned to dodge moving obstacles using dynamic obstacle handling techniques.
+2. **Custom Paths for Diverse Layouts**: Environment adaptable to various hospital settings.
+3. **Learning Optimal Path**: Rovers trained to take the shortest route to delivery rooms, avoiding obstacles.
+
+## Bonus: Real-World Application
+
+1. **Healthcare System Integration**: Enhances delivery system within hospital settings, benefiting patient care and outcomes.
+2. **Simulating Hospital Layouts**: Reflects real-world scenarios with hospital corridors, obstacles, and RxRovers.
+3. **Complex Navigation Challenges**: Optimizes path planning and avoids dynamic/static obstacles.
+4. **Adaptable Environment**: Can be modified to different healthcare settings.
+
+## References
+
+1. [Deep Reinforcement Learning DQN for Multi-Agent Environment](https://medium.com/yellowme/deep-reinforcement-learning-dqn-for-multi-agent-environment-5f4fae1a9ff5)
+2. [Warehouse Robot Path Planning](https://github.com/LyapunovJingci/Warehouse_Robot_Path_Planning) for path planning and optimization with obstacle avoidance.
+3. [Reinforcement Learning (DQN) Tutorial | PyTorch Tutorials](https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html)
+4. [Deep Q Learning (DQN) using PyTorch](https://medium.com/@vignesh.g1609/deep-q-learning-dqn-using-pytorch-a31f02a910ac)
+
+---

Report.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a28e62aa4cfc411d65a8b745759d810d14b0674110e044bfbd672f0f991f26ea
+size 3280745

rx_rover_Enhanced_Environment.ipynb

@@ -0,0 +1,278 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Environment - Enhanced"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gym\n",
+    "from gym import spaces\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\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\n",
+    "import matplotlib.image as mpimg"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "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      # 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()\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",
+    "\n",
+    "        rover_start_img_path='images/rover_moving.png'   \n",
+    "        rover_moving_img_path='images/rover_moving.png' \n",
+    "        rover_dest_img_path='images/rover_dest.png'     \n",
+    "        rover_human_collision_path='images/rover_human_collision.png' \n",
+    "        rover_room_collision_path='images/rover_room_collision.png'   \n",
+    "        rover_desk_collision_path='images/rover_desk_collision.png'   \n",
+    "        rover_rover_collision_path='images/rover_rover_collision.png' \n",
+    "        desk_img_path='images/desk.png'\n",
+    "        room_img_path='images/room.png'   \n",
+    "        human_img_path='images/human.png' \n",
+    "        target_img_path='images/target.png' \n",
+    "\n",
+    "\n",
+    "        for i, pos in enumerate(self.rover_positions):\n",
+    "           \n",
+    "            if self.rover_done[i]:\n",
+    "                rover_img=mpimg.imread(rover_dest_img_path)  \n",
+    "            elif np.array_equal(pos, self.rover_positions[i]):\n",
+    "                rover_img=mpimg.imread(rover_start_img_path) \n",
+    "            elif self._is_human_adjacent(pos):\n",
+    "                rover_img=mpimg.imread(rover_human_collision_path) \n",
+    "            elif self._collision(pos, i):\n",
+    "               \n",
+    "                if any(np.array_equal(pos, pos) for pos in self.rooms):\n",
+    "                    rover_img=mpimg.imread(rover_room_collision_path)\n",
+    "                elif any(np.array_equal(pos, pos) for pos in self.operation_desks):\n",
+    "                    rover_img=mpimg.imread(rover_desk_collision_path)\n",
+    "                elif any(np.array_equal(pos, self.rover_positions[i]) for i in range(len(self.rover_positions)) if i != 0):\n",
+    "                    rover_img=mpimg.imread(rover_rover_collision_path)\n",
+    "            else:\n",
+    "                rover_img=mpimg.imread(rover_moving_img_path)  \n",
+    "            ax.imshow(rover_img, extent=(pos[0]-0.5, pos[0]+0.5, pos[1]-0.5, pos[1]+0.5))\n",
+    "\n",
+    "      \n",
+    "        for pos in self.operation_desks:\n",
+    "            desk_img=mpimg.imread(desk_img_path)\n",
+    "            ax.imshow(desk_img, extent=(pos[0]-0.5, pos[0]+0.5, pos[1]-0.5, pos[1]+0.5))\n",
+    "\n",
+    "        for pos in self.rooms:\n",
+    "            room_img=mpimg.imread(room_img_path)\n",
+    "            ax.imshow(room_img, extent=(pos[0]-0.5, pos[0]+0.5, pos[1]-0.5, pos[1]+0.5))\n",
+    "\n",
+    "        human_img=mpimg.imread(human_img_path)\n",
+    "        ax.imshow(human_img, extent=(self.human_position[0]-0.5, self.human_position[0]+0.5, self.human_position[1]-0.5, self.human_position[1]+0.5))\n",
+    "\n",
+    "        for pos in self.targets:\n",
+    "            target_img=mpimg.imread(target_img_path)\n",
+    "            ax.imshow(target_img, extent=(pos[0]-0.5, pos[0]+0.5, pos[1]-0.5, pos[1]+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()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial Setup\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x700 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "env=RoverGridEnv()\n",
+    "print(\"Initial Setup\")\n",
+    "observation=env.reset()\n",
+    "env.render()"
+   ]
+  }
+ ],
+ "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
+}