Continuous_Control_run.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from unityagents import UnityEnvironment\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "from collections import deque\n",
    "import matplotlib.pyplot as plt\n",
    "from ddpg_agent import Agent\n",
    "from ddpg_model import Actor, Critic\n",
    "\n",
    "import torch\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:unityagents:\n",
      "'Academy' started successfully!\n",
      "Unity Academy name: Academy\n",
      "        Number of Brains: 1\n",
      "        Number of External Brains : 1\n",
      "        Lesson number : 0\n",
      "        Reset Parameters :\n",
      "\t\tgoal_speed -> 1.0\n",
      "\t\tgoal_size -> 5.0\n",
      "Unity brain name: ReacherBrain\n",
      "        Number of Visual Observations (per agent): 0\n",
      "        Vector Observation space type: continuous\n",
      "        Vector Observation space size (per agent): 33\n",
      "        Number of stacked Vector Observation: 1\n",
      "        Vector Action space type: continuous\n",
      "        Vector Action space size (per agent): 4\n",
      "        Vector Action descriptions: , , , \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of agents: 20\n",
      "Size of each action: 4\n",
      "There are 20 agents. Each observes a state with length: 33\n",
      "The state for the first agent looks like: [ 0.00000000e+00 -4.00000000e+00  0.00000000e+00  1.00000000e+00\n",
      " -0.00000000e+00 -0.00000000e+00 -4.37113883e-08  0.00000000e+00\n",
      "  0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
      "  0.00000000e+00  0.00000000e+00 -1.00000000e+01  0.00000000e+00\n",
      "  1.00000000e+00 -0.00000000e+00 -0.00000000e+00 -4.37113883e-08\n",
      "  0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n",
      "  0.00000000e+00  0.00000000e+00  5.75471878e+00 -1.00000000e+00\n",
      "  5.55726624e+00  0.00000000e+00  1.00000000e+00  0.00000000e+00\n",
      " -1.68164849e-01]\n"
     ]
    }
   ],
   "source": [
    "env = UnityEnvironment(file_name='Reacher_Linux_NoVis_20/Reacher.x86')\n",
    "\n",
    "# get the default brain\n",
    "brain_name = env.brain_names[0]\n",
    "brain = env.brains[brain_name]\n",
    "\n",
    "# reset the environment\n",
    "env_info = env.reset(train_mode=False)[brain_name]\n",
    "\n",
    "# number of agents\n",
    "num_agents = len(env_info.agents)\n",
    "print('Number of agents:', num_agents)\n",
    "\n",
    "# size of each action\n",
    "action_size = brain.vector_action_space_size\n",
    "print('Size of each action:', action_size)\n",
    "\n",
    "# examine the state space \n",
    "states = env_info.vector_observations\n",
    "state_size = states.shape[1]\n",
    "print('There are {} agents. Each observes a state with length: {}'.format(states.shape[0], state_size))\n",
    "print('The state for the first agent looks like:', states[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = np.zeros(num_agents)\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "random_seed=0\n",
    "Agent.actor_local = Actor(state_size, action_size, random_seed).to(device)\n",
    "Agent.actor_local.load_state_dict(torch.load('checkpoint_actor.pth',map_location={'cuda:0': 'cpu'}))\n",
    "#agent.actor_local.load_state_dict(torch.load('checkpoint_actor.pth'))\n",
    "#agent.critic_local.load_state_dict(torch.load('checkpoint_critic.pth'))\n",
    "\n",
    "agents = []                        # list of agents, depending on agents needed in the current environment\n",
    "for _ in range(num_agents):\n",
    "    agents.append(Agent(state_size, \n",
    "                        action_size, \n",
    "                        random_seed=0,\n",
    "                        buffer_size=int(1e6),  # replay buffer size (default: int(1e6))\n",
    "                        batch_size=1024,       # minibatch size (default: 128)\n",
    "                        gamma=0.99,            # discount factor (default: 0.99)\n",
    "                        tau=1e-3,              # for soft update of target parameters (default: 1e-3)\n",
    "                        lr_actor=1e-3,         # learning rate of the actor (default: 1e-3)\n",
    "                        lr_critic=1e-4,        # learning rate of the critic (default: 1e-4)\n",
    "                        weight_decay=0.        # L2 weight decay (default: 3e-4)\n",
    "                        )\n",
    "                   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score: 35.55\tmin: 8.78\tmax: 39.61\n",
      "Scores: [37.09999917 39.53999912 37.14999917 35.9799992  39.29999912 38.34999914\n",
      " 39.02999913 31.1099993  34.45999923 37.75999916 38.47999914  8.7799998\n",
      " 39.60999911 39.59999911 37.96999915 30.72999931 38.72999913 37.62999916\n",
      " 31.3799993  38.37999914]\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    actions = np.array([agents[i].act(states[i]) for i in range(num_agents)])\n",
    "\n",
    "    env_info = env.step(actions)[brain_name]        # send the action to the environment\n",
    "    next_states = env_info.vector_observations     # get the next state\n",
    "    rewards = env_info.rewards                     # get the reward\n",
    "    dones = env_info.local_done        \n",
    "\n",
    "    states = next_states\n",
    "    scores += rewards\n",
    "\n",
    "    print('\\rScore: {:.2f}\\tmin: {:.2f}\\tmax: {:.2f}'\n",
    "              .format(np.mean(scores), np.min(scores), np.max(scores)), end=\"\") \n",
    "    \n",
    "    if np.any(dones):\n",
    "        break\n",
    "        \n",
    "print(\"\\nScores: {}\".format(scores))\n",
    "\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "drlnd",
   "language": "python",
   "name": "drlnd"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}