use_ppo_fixedtarget_train.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pp/anaconda3/envs/baseline/lib/python3.6/site-packages/gym/logger.py:34: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
      "  warnings.warn(colorize(\"%s: %s\" % (\"WARN\", msg % args), \"yellow\"))\n"
     ]
    }
   ],
   "source": [
    "import gym\n",
    "from gym import error, spaces, utils\n",
    "from gym.utils import seeding\n",
    "\n",
    "import os\n",
    "import pybullet as p\n",
    "import pybullet_data\n",
    "import math\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "from gym_myrobot.envs.robot_reach import ReachEnv\n",
    "# robenv = ReachEnv(reward_type='dense',usegripper=True, use_fixed_target=True, usegui=False, fixed_target=[0.1, 0.1, 0.1])  # reward type = 'sparse' 时，为稀疏奖励，可以配合her算法使用\n",
    "robenv = ReachEnv(reward_type='sparse',usegripper=True, usegui=True)  # reward type = 'sparse' 时，为稀疏奖励，可以配合her算法使用\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.distributions import MultivariateNormal\n",
    "from torch.distributions import Categorical\n",
    "import numpy as np\n",
    "import gym\n",
    "import os\n",
    "\n",
    "device = torch.device('cpu')\n",
    "if(torch.cuda.is_available()):\n",
    "    device = torch.device('cuda:0')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'observation': array([ 2.86000013e-01,  6.88214270e-22,  2.04500005e-01,  0.00000000e+00,\n",
       "        -0.00000000e+00,  0.00000000e+00]),\n",
       " 'achieved_goal': array([2.86000013e-01, 6.88214270e-22, 2.04500005e-01]),\n",
       " 'desired_goal': array([ 0.1991835 , -0.13102981,  0.1779861 ])}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "robenv.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "writer_actor = SummaryWriter('PPO_logs/actor')\n",
    "writer_critic = SummaryWriter('PPO_logs/critic')\n",
    "writer_scalars = SummaryWriter('PPO_logs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RolloutBuffer:\n",
    "    def __init__(self):\n",
    "        self.actions = []\n",
    "        self.states = []\n",
    "        self.logprobs = []\n",
    "        self.rewards = []\n",
    "        self.is_terminals = []\n",
    "        \n",
    "    def clear(self):\n",
    "        del self.actions[:]\n",
    "        del self.states[:]\n",
    "        del self.logprobs[:]\n",
    "        del self.rewards[:]\n",
    "        del self.is_terminals[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    '''给出一个分布的均值'''\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        super(Actor, self).__init__()\n",
    "        self.linear1 = nn.Linear(state_dim, 64)\n",
    "        self.linear2 = nn.Linear(64, 64)\n",
    "        self.linear3 = nn.Linear(64, action_dim)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = torch.tanh(self.linear1(state))\n",
    "        x = torch.tanh(self.linear2(x))\n",
    "        x = torch.tanh(self.linear3(x))\n",
    "        return x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_dim):\n",
    "        super(Critic, self).__init__()\n",
    "        self.linear1 = nn.Linear(state_dim, 64)\n",
    "        self.linear2 = nn.Linear(64, 64)\n",
    "        self.linear3 = nn.Linear(64, 1)\n",
    "    \n",
    "    def forward(self, state):\n",
    "        x = torch.tanh(self.linear1(state))\n",
    "        x = torch.tanh(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActorCritic(nn.Module):\n",
    "    '''把Actor和Critic封装到一起了，这样可以直接评估，比较简单'''\n",
    "    def __init__(self, state_dim, action_dim, action_std_init):\n",
    "        super(ActorCritic, self).__init__()\n",
    "        \n",
    "        self.action_dim = action_dim\n",
    "        self.action_var = torch.full((self.action_dim,), action_std_init**2).to(device) # 把一个标量变成动作维度的向量\n",
    "        \n",
    "        self.actor = Actor(state_dim, action_dim)\n",
    "        self.critic = Critic(state_dim)\n",
    "        \n",
    "    def set_action_std(self, new_action_std):\n",
    "        self.action_var = torch.full((self.action_dim,), new_action_std**2).to(device)\n",
    "        \n",
    "    def act(self, state):\n",
    "        '''输入单个状态，得到动作和log, 是之后要用到选择动作的子函数'''\n",
    "        action_mean = self.actor(state)           # 一行均值，列数是动作维度，1维向量\n",
    "        cov_mat = torch.diag(self.action_var)     # 一行方差，可以直接diag\n",
    "        dist = MultivariateNormal(action_mean, cov_mat)\n",
    "        action = dist.sample()\n",
    "        action_logprob = dist.log_prob(action)\n",
    "        \n",
    "        return action.detach(), action_logprob.detach()  # [x,x,x], x\n",
    "    \n",
    "    def evaluate(self, state, action):\n",
    "        '''输入一批状态和动作，得到一批评估结果, .log_prob(action)中action不必是这个dist筛出来的'''\n",
    "        action_mean = self.actor(state)          # 好多行均值，列数是动作维度，2维矩阵\n",
    "        action_var = self.action_var.expand_as(action_mean)  # 方差也要变成好多行\n",
    "        cov_mat = torch.diag_embed(action_var)   # 不能直接diag，要用diag_embed\n",
    "        dist = MultivariateNormal(action_mean, cov_mat)\n",
    "        \n",
    "        # 如果动作的dim是1，则需要给他改变一下形状，\n",
    "        # 因为多维action[batch_size, action_dim]，而单维的action[batch_size]，少了个维度,要变成[bactch_size,1]\n",
    "        if self.action_dim == 1:\n",
    "            action = action.reshape(-1, 1)   # [batch_size, 1] 只有第二个维度有，下面的log_prob才好使\n",
    "        \n",
    "        action_logprobs = dist.log_prob(action)\n",
    "        state_values = self.critic(state)\n",
    "        dist_entropy = dist.entropy()\n",
    "        \n",
    "        return action_logprobs, state_values, dist_entropy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PPO:\n",
    "    def __init__(self, env, lr_actor, lr_critic, gamma, K_epochs, eps_clip, actions_std_init=0.6):\n",
    "        self.env = env\n",
    "        self.state_dim = 6\n",
    "        self.action_dim = env.action_space.shape[0]\n",
    "        self.max_action = float(env.action_space.high[0])\n",
    "        \n",
    "        self.action_std = actions_std_init\n",
    "        self.gamma = gamma\n",
    "        self.K_epochs = K_epochs\n",
    "        self.eps_clip = eps_clip\n",
    "        self.actions_std_init = actions_std_init\n",
    "        self.buffer = RolloutBuffer()\n",
    "        \n",
    "        # 初始化Actor_Critic 整体网络\n",
    "        self.policy = ActorCritic(self.state_dim, self.action_dim, self.action_std).to(device)\n",
    "        self.policy_old = ActorCritic(self.state_dim, self.action_dim, self.action_std).to(device)\n",
    "        \n",
    "        # 初始化优化器和损失函数\n",
    "        # 因为一个policy里面有两个网络，所以优化器的参数和学习率是两个字典组成的列表\n",
    "        self.optimizer = torch.optim.Adam([\n",
    "            {'params':self.policy.actor.parameters(), 'lr':lr_actor},\n",
    "            {'params':self.policy.critic.parameters(), 'lr':lr_critic}\n",
    "        ])\n",
    "\n",
    "        self.loss_fn = nn.MSELoss()\n",
    "        self.summary = {}\n",
    "    \n",
    "    def set_action_std(self, new_action_std):\n",
    "        '''给ActorCritic类设置一下std'''\n",
    "        self.policy.set_action_std(new_action_std)\n",
    "        self.policy_old.set_action_std(new_action_std)\n",
    " \n",
    "    def decay_action_std(self, action_std_decay_rate, min_action_std):\n",
    "        '''随着步数增大， 减小action的方差, 并给两个actor网络设置方差'''\n",
    "        self.action_std -= action_std_decay_rate\n",
    "        self.action_std = round(self.action_std, 4)      # 保留四位小数\n",
    "        if (self.action_std <= min_action_std):\n",
    "            self.action_std = min_action_std\n",
    "        self.set_action_std(self.action_std)\n",
    "    \n",
    "    def select_action(self, state):\n",
    "        '''根据状态获取动作，得到的动作是用于与环境交互的， 不用于update'''\n",
    "        with torch.no_grad():\n",
    "            state = torch.FloatTensor(state).to(device)\n",
    "            action, action_log_prob = self.policy_old.act(state)\n",
    "        \n",
    "        # 选择动作的同时，把state， action, action_log_prob 加入buffer,都是tensor\n",
    "        self.buffer.states.append(state)\n",
    "        self.buffer.actions.append(action)    \n",
    "        self.buffer.logprobs.append(action_log_prob)\n",
    "        \n",
    "        return self.max_action * action.detach().cpu().numpy()\n",
    "    \n",
    "    def test_select_action(self, state):\n",
    "        with torch.no_grad():\n",
    "            state = torch.FloatTensor(state).to(device)\n",
    "            action = self.policy_old.actor(state)\n",
    "            return self.max_action * action.detach().cpu().numpy()\n",
    "         \n",
    "    def update(self):\n",
    "        # 先把reward转换为能用的折扣过的rewards\n",
    "        rewards = []\n",
    "        discounted_reward = 0\n",
    "        for reward, is_terminal in zip(reversed(self.buffer.rewards), reversed(self.buffer.is_terminals)):\n",
    "            if is_terminal:\n",
    "                discounted_reward = 0\n",
    "            discounted_reward = reward + (self.gamma * discounted_reward)\n",
    "            rewards.insert(0, discounted_reward)  # 把折扣过的动作重头排列\n",
    "        # 归一化reward\n",
    "        rewards = torch.FloatTensor(rewards).to(device)\n",
    "        rewards = (rewards - rewards.mean())/(rewards.std() + 1e-7)  # [4000]\n",
    "        \n",
    "        # buffer里面的这三个东西本来就是tensor，所以纵向连接dim=0也要用tensor的连接方法\n",
    "        old_states = torch.squeeze(torch.stack(self.buffer.states, dim=0)).detach().to(device)   # [4000, 6]\n",
    "        old_actions = torch.squeeze(torch.stack(self.buffer.actions, dim=0)).detach().to(device) # [4000, 4]\n",
    "        old_logprobs = torch.squeeze(torch.stack(self.buffer.logprobs, dim=0)).detach().to(device) # [4000]\n",
    "        \n",
    "        # update\n",
    "        for _ in range(self.K_epochs):\n",
    "            \n",
    "            # 用现在的actor和critic，评估旧的states和actions\n",
    "            logprobs, state_values, dist_entropy = self.policy.evaluate(old_states, old_actions)\n",
    "        #   [4000],   [4000, 1]     [4000]\n",
    "            \n",
    "            # 把state_values 变成[batch_size] 和rewards形状一致\n",
    "            state_values = torch.squeeze(state_values)\n",
    "            \n",
    "            # 计算ratio\n",
    "            ratios = torch.exp(logprobs - old_logprobs.detach())\n",
    "\n",
    "            # 计算loss\n",
    "            advantages = rewards - state_values.detach()\n",
    "            surr1 = ratios *  advantages\n",
    "            surr2 = torch.clamp(ratios, 1-self.eps_clip, 1+self.eps_clip) * advantages\n",
    "            \n",
    "            # PPO 的最终loss\n",
    "            loss = -torch.min(surr1, surr2) - 0.01 * dist_entropy + 0.5 * self.loss_fn(state_values, rewards) #[4000]\n",
    "            loss = loss.mean()\n",
    "            self.summary['loss'] = loss.item()\n",
    "            \n",
    "            # 梯度更新\n",
    "            self.optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            self.optimizer.step()\n",
    "        \n",
    "        # 更新目标网络，用load模型参数的方法来硬更新模型\n",
    "        self.policy_old.load_state_dict(self.policy.state_dict())\n",
    "        \n",
    "        # 清空buffer\n",
    "        self.buffer.clear()        \n",
    "        \n",
    "    \n",
    "    def save(self, checkpoint_path):\n",
    "        '''只保存模型参数'''\n",
    "        torch.save(self.policy_old.state_dict(), checkpoint_path)\n",
    "        \n",
    "    def load(self, checkpoint_path):\n",
    "        self.policy_old.load_state_dict(torch.load(checkpoint_path))\n",
    "        self.policy.load_state_dict(torch.load(checkpoint_path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_ep_len = 1000                # 每个回合最大步数\n",
    "max_train_timesteps = int(3e6)\n",
    "action_std = 0.6\n",
    "action_std_decay_rate = 0.05\n",
    "min_action_std = 0.1\n",
    "action_std_decay_freq = int(2.5e5)  # 多少步减小一下std\n",
    "print_freq = max_ep_len * 10        # 多少步打印一下奖励\n",
    "save_model_freq = int(1e5)          # 多少步保存一下模型\n",
    "\n",
    "update_timestep = max_ep_len*4  # buffer存4000组数据训练一次\n",
    "K_epochs = 80                   # update一次更新网络80次\n",
    "\n",
    "eps_clip = 0.2\n",
    "gamma = 0.99\n",
    "lr_actor = 0.0003\n",
    "lr_critic = 0.001\n",
    "\n",
    "env = robenv\n",
    "\n",
    "ppo_agent = PPO(env, lr_actor, lr_critic, gamma, K_epochs, eps_clip, action_std)\n",
    "\n",
    "directory = 'PPO_weigths' + '/' + 'arm' + '/'\n",
    "if not os.path.exists(directory):\n",
    "      os.makedirs(directory)\n",
    "# checkpoint_path = directory + 'ppo_{}_dgx.pth'.format('arm')  # 模型保存会覆盖这个文件，整套训练下来，就保存一个文件\n",
    "checkpoint_path = directory + 'ppo_{}.pth'.format('arm')  # 模型保存会覆盖这个文件，整套训练下来，就保存一个文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer_actor.add_graph(ppo_agent.policy.actor, torch.FloatTensor(env.reset()['observation']).cuda())\n",
    "writer_critic.add_graph(ppo_agent.policy.critic, torch.FloatTensor(env.reset()['observation']).cuda())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 训练代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pp/deeplearning/open_manipulator_X_RL/gym_myrobot/envs/robot_env.py:81: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n",
      "  jointPoses_now = np.array(jointPoses_now)[:, 0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode : 9 \t\t Timestep : 10000 \t\t Average Reward : -240.97\n",
      "Episode : 19 \t\t Timestep : 20000 \t\t Average Reward : -215.06\n",
      "Episode : 29 \t\t Timestep : 30000 \t\t Average Reward : -196.99\n",
      "Episode : 39 \t\t Timestep : 40000 \t\t Average Reward : -153.76\n",
      "Episode : 49 \t\t Timestep : 50000 \t\t Average Reward : -118.07\n",
      "Episode : 59 \t\t Timestep : 60000 \t\t Average Reward : -120.95\n",
      "Episode : 69 \t\t Timestep : 70000 \t\t Average Reward : -111.68\n",
      "Episode : 79 \t\t Timestep : 80000 \t\t Average Reward : -106.7\n",
      "Episode : 89 \t\t Timestep : 90000 \t\t Average Reward : -91.34\n",
      "Episode : 99 \t\t Timestep : 100000 \t\t Average Reward : -95.48\n",
      "Episode : 109 \t\t Timestep : 110000 \t\t Average Reward : -112.22\n",
      "Episode : 119 \t\t Timestep : 120000 \t\t Average Reward : -103.7\n",
      "Episode : 129 \t\t Timestep : 130000 \t\t Average Reward : -84.82\n",
      "Episode : 139 \t\t Timestep : 140000 \t\t Average Reward : -91.86\n",
      "Episode : 149 \t\t Timestep : 150000 \t\t Average Reward : -89.04\n",
      "Episode : 159 \t\t Timestep : 160000 \t\t Average Reward : -79.54\n",
      "Episode : 169 \t\t Timestep : 170000 \t\t Average Reward : -81.69\n",
      "Episode : 179 \t\t Timestep : 180000 \t\t Average Reward : -86.28\n",
      "Episode : 189 \t\t Timestep : 190000 \t\t Average Reward : -80.27\n",
      "Episode : 199 \t\t Timestep : 200000 \t\t Average Reward : -87.3\n",
      "Episode : 209 \t\t Timestep : 210000 \t\t Average Reward : -78.9\n",
      "Episode : 219 \t\t Timestep : 220000 \t\t Average Reward : -70.62\n",
      "Episode : 229 \t\t Timestep : 230000 \t\t Average Reward : -71.22\n",
      "Episode : 239 \t\t Timestep : 240000 \t\t Average Reward : -77.98\n",
      "Episode : 249 \t\t Timestep : 250000 \t\t Average Reward : -73.69\n",
      "Episode : 259 \t\t Timestep : 260000 \t\t Average Reward : -65.32\n",
      "Episode : 269 \t\t Timestep : 270000 \t\t Average Reward : -58.55\n",
      "Episode : 279 \t\t Timestep : 280000 \t\t Average Reward : -60.97\n",
      "Episode : 289 \t\t Timestep : 290000 \t\t Average Reward : -67.09\n",
      "Episode : 299 \t\t Timestep : 300000 \t\t Average Reward : -56.77\n",
      "Episode : 309 \t\t Timestep : 310000 \t\t Average Reward : -57.53\n",
      "Episode : 319 \t\t Timestep : 320000 \t\t Average Reward : -56.26\n",
      "Episode : 329 \t\t Timestep : 330000 \t\t Average Reward : -58.49\n",
      "Episode : 339 \t\t Timestep : 340000 \t\t Average Reward : -55.1\n",
      "Episode : 349 \t\t Timestep : 350000 \t\t Average Reward : -59.26\n",
      "Episode : 359 \t\t Timestep : 360000 \t\t Average Reward : -60.8\n",
      "Episode : 369 \t\t Timestep : 370000 \t\t Average Reward : -61.22\n",
      "Episode : 379 \t\t Timestep : 380000 \t\t Average Reward : -60.63\n",
      "Episode : 389 \t\t Timestep : 390000 \t\t Average Reward : -60.37\n",
      "Episode : 399 \t\t Timestep : 400000 \t\t Average Reward : -60.96\n",
      "Episode : 409 \t\t Timestep : 410000 \t\t Average Reward : -56.8\n",
      "Episode : 419 \t\t Timestep : 420000 \t\t Average Reward : -54.43\n",
      "Episode : 429 \t\t Timestep : 430000 \t\t Average Reward : -53.84\n",
      "Episode : 439 \t\t Timestep : 440000 \t\t Average Reward : -53.02\n",
      "Episode : 449 \t\t Timestep : 450000 \t\t Average Reward : -53.78\n",
      "Episode : 459 \t\t Timestep : 460000 \t\t Average Reward : -53.94\n",
      "Episode : 469 \t\t Timestep : 470000 \t\t Average Reward : -55.2\n",
      "Episode : 479 \t\t Timestep : 480000 \t\t Average Reward : -55.24\n",
      "Episode : 489 \t\t Timestep : 490000 \t\t Average Reward : -60.93\n",
      "Episode : 499 \t\t Timestep : 500000 \t\t Average Reward : -54.42\n",
      "Episode : 509 \t\t Timestep : 510000 \t\t Average Reward : -52.37\n",
      "Episode : 519 \t\t Timestep : 520000 \t\t Average Reward : -52.99\n",
      "Episode : 529 \t\t Timestep : 530000 \t\t Average Reward : -53.89\n",
      "Episode : 539 \t\t Timestep : 540000 \t\t Average Reward : -54.64\n",
      "Episode : 549 \t\t Timestep : 550000 \t\t Average Reward : -53.17\n",
      "Episode : 559 \t\t Timestep : 560000 \t\t Average Reward : -52.27\n",
      "Episode : 569 \t\t Timestep : 570000 \t\t Average Reward : -51.25\n",
      "Episode : 579 \t\t Timestep : 580000 \t\t Average Reward : -50.84\n",
      "Episode : 589 \t\t Timestep : 590000 \t\t Average Reward : -52.45\n",
      "Episode : 599 \t\t Timestep : 600000 \t\t Average Reward : -52.65\n",
      "Episode : 609 \t\t Timestep : 610000 \t\t Average Reward : -50.75\n",
      "Episode : 619 \t\t Timestep : 620000 \t\t Average Reward : -51.8\n",
      "Episode : 629 \t\t Timestep : 630000 \t\t Average Reward : -53.49\n",
      "Episode : 639 \t\t Timestep : 640000 \t\t Average Reward : -53.99\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-3269fb6998e5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[0;31m#         env.render()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m         \u001b[0maction\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mppo_agent\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mselect_action\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# 已经存入了三个东西到buffer了！\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m         \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreward\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maction\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 直接更新下一个状态到当前状态，没有出现next_state\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m         \u001b[0mstate\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'observation'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/deeplearning/open_manipulator_X_RL/gym_myrobot/envs/robot_reach.py\u001b[0m in \u001b[0;36mstep\u001b[0;34m(self, action)\u001b[0m\n\u001b[1;32m    100\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0m_\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_substeps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    101\u001b[0m             \u001b[0;34m'''仿真n个pybullet时间步数，因为怕执行不完'''\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 102\u001b[0;31m             \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstepSimulation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    103\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    104\u001b[0m         \u001b[0mobs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_obs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "time_step = 0\n",
    "i_episod = 0\n",
    "\n",
    "# printing and logging variables\n",
    "print_running_reward = 0\n",
    "print_running_episodes = 0\n",
    "\n",
    "while time_step <= max_train_timesteps:  # 以最大步数作为终止条件，同之前的第二种训练方法\n",
    "    state = env.reset()\n",
    "    state = state['observation']\n",
    "    current_ep_reward = 0\n",
    "    ep_step = 0\n",
    "    for t in range(max_ep_len):\n",
    "#         env.render()\n",
    "        action = ppo_agent.select_action(state)  # 已经存入了三个东西到buffer了！\n",
    "        state, reward, done, _ = env.step(action) # 直接更新下一个状态到当前状态，没有出现next_state\n",
    "        state = state['observation']\n",
    "        \n",
    "        ppo_agent.buffer.rewards.append(reward)\n",
    "        ppo_agent.buffer.is_terminals.append(done)\n",
    "        \n",
    "        time_step += 1\n",
    "        current_ep_reward += reward\n",
    "        ep_step += 1\n",
    "        \n",
    "        if time_step % update_timestep == 0:\n",
    "            ppo_agent.update()\n",
    "            writer_scalars.add_scalar('loss', ppo_agent.summary['loss'], time_step)\n",
    "        \n",
    "        if time_step % action_std_decay_freq == 0:\n",
    "            ppo_agent.decay_action_std(action_std_decay_rate, min_action_std)\n",
    "            \n",
    "        # printing average reward\n",
    "        if time_step % print_freq == 0:\n",
    "            # 打印这么些回合的平均回合奖励\n",
    "            print_avg_reward = print_running_reward / print_running_episodes\n",
    "            print_avg_reward = round(print_avg_reward, 2)\n",
    "\n",
    "            print(\"Episode : {} \\t\\t Timestep : {} \\t\\t Average Reward : {}\".format(i_episod, time_step, print_avg_reward))\n",
    "\n",
    "            print_running_reward = 0\n",
    "            print_running_episodes = 0\n",
    "        \n",
    "        if time_step % save_model_freq == 0:\n",
    "            ppo_agent.save(checkpoint_path)\n",
    "            \n",
    "        if done:\n",
    "            break\n",
    "    \n",
    "    writer_scalars.add_scalar('episode_reward', current_ep_reward, i_episod)\n",
    "    print_running_reward += current_ep_reward\n",
    "    print_running_episodes += 1\n",
    "    i_episod += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import rospy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 仿真环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "envsim = robenv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ppo_agent_new = PPO(envsim, lr_actor, lr_critic, gamma, K_epochs, eps_clip, action_std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ppo_agent_new.load(checkpoint_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "for j in range(1):\n",
    "    states_sim = []\n",
    "    state = envsim.reset()\n",
    "    state = state['observation']\n",
    "    for i in range(500):\n",
    "        action = ppo_agent_new.test_select_action(state)\n",
    "        state, reward, done, _ = envsim.step(action)\n",
    "        rospy.sleep(0.02)\n",
    "        state = state['observation']\n",
    "        states_sim.append(state)\n",
    "        if done:\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(500, 6)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "states_sim = np.array(states_sim)\n",
    "states_sim.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "states_sim_pose = states_sim[:, :3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f1ed0507668>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1f002084a8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = np.arange(0, 500, 1)\n",
    "plt.plot(t, states_sim_pose[:,0],'r', t,states_sim_pose[:,1],'b', t, states_sim_pose[:,2],'g')\n",
    "plt.xlabel('time-step')\n",
    "plt.ylabel('poses')\n",
    "plt.legend(['x_sim','y_sim','z_sim'], loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 真实环境 \n",
    "### 需要用到真实的设备，openmanipulatorx，需要自行购买"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pp/anaconda3/envs/baseline/lib/python3.6/site-packages/gym/logger.py:34: UserWarning: \u001b[33mWARN: Box bound precision lowered by casting to float32\u001b[0m\n",
      "  warnings.warn(colorize(\"%s: %s\" % (\"WARN\", msg % args), \"yellow\"))\n"
     ]
    }
   ],
   "source": [
    "from gym_myrobot.envs.real_arm_env import RealarmEnv\n",
    "envreal = RealarmEnv(reward_type='dense',use_gripper=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.16179898383580413\n",
      "-0.16088894104076631\n",
      "-0.15952422053283438\n",
      "-0.15815997226319206\n",
      "-0.15556745343061162\n",
      "-0.15543353213846364\n",
      "-0.15330395319225398\n",
      "-0.15183178825678204\n",
      "-0.15004834602806033\n",
      "-0.14823148712329892\n"
     ]
    }
   ],
   "source": [
    "for j in range(1):\n",
    "    states_real = []\n",
    "    state = envreal.reset()\n",
    "    state = state['observation']\n",
    "    for i in range(500):\n",
    "        action = ppo_agent_new.test_select_action(state)\n",
    "        state, reward, done, info = envreal.step(action)\n",
    "        print(reward)\n",
    "        state = state['observation']\n",
    "        states_real.append(state)\n",
    "        if done:\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "states_real = np.array(states_real)\n",
    "states_real_pose = states_real[:, :3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f05e0066a58>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f05e0066710>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = np.arange(0, 500, 1)\n",
    "plt.plot(t, states_real_pose[:,0],'r--', t,states_real_pose[:,1],'b--', t, states_real_pose[:,2],'g--')\n",
    "plt.xlabel('time-step')\n",
    "plt.ylabel('poses')\n",
    "plt.legend(['x_real','y_real','z_real'], loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 单点跟踪仿真和实物对比"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f05c054b4e0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f05c054b438>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "t = np.arange(0, 500, 1)\n",
    "plt.plot(t, states_real_pose[:,0],'r--', t,states_real_pose[:,1],'b--', t, states_real_pose[:,2],'g--', t, states_sim_pose[:,0],'r', t,states_sim_pose[:,1],'b', t, states_sim_pose[:,2],'g')\n",
    "plt.xlabel('time-step')\n",
    "plt.ylabel('poses')\n",
    "plt.legend(['x_real','y_real','z_real','x_sim', 'y_sim', 'z_sim'], loc='best')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "be7c24b6c677481f72574ad8dd0426aa142df58920f5739129da1878e2bc9311"
  },
  "kernelspec": {
   "display_name": "Python 3.6.13 64-bit ('baseline': conda)",
   "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.6.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}