14.TD3测试.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"TD3测试","provenance":[],"collapsed_sections":[],"toc_visible":true,"authorship_tag":"ABX9TyO9cWelTpiPUvHMnwZzzTRR"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","metadata":{"id":"khN5l4wYo0s8"},"source":["和DDPG类似，主要是加了一个Delay的actor更新过程，然后给Critic添加了Double的缓解过估计属性，然后是学习过程中给a添加了一个扰动。效果可能还算不错。"]},{"cell_type":"markdown","metadata":{"id":"8QOsLKIpbnhn"},"source":["# 导入函数库"]},{"cell_type":"code","metadata":{"id":"TQzCwgeibQzp","executionInfo":{"status":"ok","timestamp":1616310778100,"user_tz":-480,"elapsed":948,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":["import torch\n","import gym\n","import numpy as np\n","import matplotlib.pyplot as plt"],"execution_count":61,"outputs":[]},{"cell_type":"code","metadata":{"id":"3L9cqFvFbSj5","executionInfo":{"status":"ok","timestamp":1616310778474,"user_tz":-480,"elapsed":1310,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":["torch.set_default_dtype(torch.float64)"],"execution_count":62,"outputs":[]},{"cell_type":"code","metadata":{"id":"LmMSLiSPbSml","executionInfo":{"status":"ok","timestamp":1616310778475,"user_tz":-480,"elapsed":1307,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":[""],"execution_count":62,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"jAXxOwW4c9sO"},"source":["# 经验池"]},{"cell_type":"code","metadata":{"id":"tXSzUw9Lc9Z2","executionInfo":{"status":"ok","timestamp":1616310778475,"user_tz":-480,"elapsed":1304,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":["class memory:\n","  def __init__(self, env, memory_length=20000, memory_minibatch=32):\n","    self.env = env\n","    self.memory_length = memory_length\n","    self.memory_minibatch = memory_minibatch\n","\n","    self.state_size = self.env.observation_space.shape[0]\n","    try:self.action_size = self.env.action_space.shape[0]\n","    except:self.action_size = 1\n","    \n","    self.memory_width = self.state_size * 2 + self.action_size + 1\n","    self.memory = np.zeros((self.memory_length, self.memory_width))\n","\n","    self.index = 0\n","    self.max_index = 0\n","\n","  def store(self, state, action, reward, next_state):\n","    transacton = np.hstack((state, action, reward, next_state))\n","    self.memory[self.index,:] = transacton\n","\n","    self.index += 1\n","    if self.index % self.memory_length == 0:\n","      self.index = 0\n","    if self.max_index < self.memory_length:\n","      self.max_index += 1\n","  \n","  def sample(self):\n","    choice_random = np.random.choice(self.max_index, self.memory_minibatch)\n","    choice_data = self.memory[choice_random,:]\n","    state = choice_data[:,0:self.state_size]\n","    action = choice_data[:,self.state_size:self.state_size+self.action_size]\n","    reward = choice_data[:,self.state_size+self.action_size:\n","                         self.state_size+self.action_size+1]\n","    next_state = choice_data[:,self.state_size+self.action_size+1:]\n","\n","    return state, action, reward, next_state\n"],"execution_count":63,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"EvaxTXVIcMvG"},"source":["# Critic 网络"]},{"cell_type":"code","metadata":{"id":"IoLSipa5bSo-","executionInfo":{"status":"ok","timestamp":1616310778476,"user_tz":-480,"elapsed":1302,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":["class critic:\n","  def __init__(self, env, hidden_dimension=100, learning_rate=1e-3, gamma=0.9):\n","    self.env = env\n","    self.hidden_dimension = hidden_dimension\n","    self.learning_rate = learning_rate\n","    self.gamma = gamma\n","\n","    self.state_dimension = self.env.observation_space.shape[0]\n","    try:self.action_dimension = self.env.action_space.shape[0]\n","    except:self.action_dimension = 1\n","\n","    self.model = self.__create_network()\n","    self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.learning_rate)\n","\n","\n","  def __create_network(self):\n","    class critic_network(torch.nn.Module):\n","      def __init__(self, state_dimension, action_dimension, hidden_dimension):\n","        super().__init__()\n","        self.state_dimension = state_dimension\n","        self.action_dimension = action_dimension\n","        self.hidden_dimension = hidden_dimension\n","\n","        self.layer_state = torch.nn.Linear(self.state_dimension, self.hidden_dimension)\n","        self.layer_action = torch.nn.Linear(self.action_dimension, self.hidden_dimension)\n","        self.layer_output = torch.nn.Linear(self.hidden_dimension, 1)\n","      \n","      def forward(self, state, action):\n","        hidden_state = self.layer_state(state)\n","        hidden_action = self.layer_action(action)\n","        hidden = hidden_state + hidden_action\n","        hidden = torch.nn.functional.relu(hidden)\n","        output = self.layer_output(hidden)\n","        return output\n","    return critic_network(self.state_dimension, self.action_dimension, self.hidden_dimension)\n"],"execution_count":64,"outputs":[]},{"cell_type":"code","metadata":{"id":"3rIuU5iJbSrl","executionInfo":{"status":"ok","timestamp":1616310778476,"user_tz":-480,"elapsed":1298,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":[""],"execution_count":64,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"yuvtzYdHcQNu"},"source":["# Actor 网络"]},{"cell_type":"code","metadata":{"id":"zJ4Lshp3bSuN","executionInfo":{"status":"ok","timestamp":1616310778476,"user_tz":-480,"elapsed":1295,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":["class actor:\n","  def __init__(self, env, hidden_dimension=30, learning_rate=1e-3):\n","    self.env = env\n","    self.hidden_dimension = hidden_dimension\n","    self.learning_rate = learning_rate\n","\n","    self.state_dimension = self.env.observation_space.shape[0]\n","    self.action_dimension = self.env.action_space.shape[0]\n","    self.action_bound = [float(self.env.action_space.low), float(self.env.action_space.high)]\n","\n","    self.model = self.__create_network()\n","    self.entropy = torch.nn.CrossEntropyLoss(reduction='none')\n","    self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.learning_rate)\n","\n","  def __create_network(self):\n","    class actor_network(torch.nn.Module):\n","      def __init__(self, state_dimension, action_dimension, action_bound, hidden_dimension):\n","        super().__init__()\n","        self.state_dimension = state_dimension\n","        self.action_dimension = action_dimension\n","        self.action_bound = action_bound\n","        self.hidden_dimension = hidden_dimension\n","\n","        self.layer_state = torch.nn.Linear(self.state_dimension, self.hidden_dimension)\n","        self.layer_output = torch.nn.Linear(self.hidden_dimension, self.action_dimension)\n","      \n","      def forward(self, state):\n","        hidden = self.layer_state(state)\n","        hidden = torch.nn.functional.relu(hidden)\n","        output = self.layer_output(hidden)\n","        output = torch.tanh(output) * torch.FloatTensor([self.action_bound[1]])\n","        return output\n","    return actor_network(self.state_dimension, self.action_dimension,\n","                   self.action_bound, self.hidden_dimension)"],"execution_count":65,"outputs":[]},{"cell_type":"code","metadata":{"id":"GucIXXl2caiu","executionInfo":{"status":"ok","timestamp":1616310778477,"user_tz":-480,"elapsed":1292,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":[""],"execution_count":65,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"6UpbccdMchNX"},"source":["# 智能体交互"]},{"cell_type":"code","metadata":{"id":"a_OkaudlcagW","executionInfo":{"status":"ok","timestamp":1616310778822,"user_tz":-480,"elapsed":1634,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":["class agent_actor_critic:\n","  def __init__(self, env_name=\"Pendulum-v0\", epoch=1000, gamma=0.9, std=3, std_target=3, delay=3):\n","    self.env_name = env_name\n","    self.epoch = epoch\n","    self.gamma = gamma\n","    self.std = std\n","    self.std_target = std_target\n","    self.delay = delay\n","    self.env = gym.make(self.env_name)\n","\n","    self.critic_network1 = critic(self.env)\n","    self.critic_network2 = critic(self.env)\n","    self.actor_network = actor(self.env)\n","    self.critic_network_target1 = critic(self.env)\n","    self.critic_network_target2 = critic(self.env)\n","    self.actor_network_target = actor(self.env)\n","    self.replace_soft(self.critic_network1.model, self.critic_network_target1.model)\n","    self.replace_soft(self.critic_network2.model, self.critic_network_target2.model)\n","    self.replace_soft(self.actor_network.model, self.actor_network_target.model)\n","    self.memory = memory(self.env)\n","\n","  def start_execute(self):\n","    self.statistic_reward = []\n","    self.learn_cnt = 0\n","    for i in range(self.epoch):\n","      state = self.env.reset()\n","      reward_total = 0\n","      while True:\n","        action = self.actor_network.model(torch.from_numpy(state))\n","        action = torch.clip(torch.normal(action, self.std), \n","                             self.actor_network.action_bound[0],\n","                             self.actor_network.action_bound[1])\n","        action = np.array(action.tolist())\n","        next_state, reward, done, info = self.env.step(action)\n","        self.memory.store(state, action, reward, next_state)\n","        reward_total += reward\n","        state = next_state\n","\n","        loss_actor,loss_critic1, loss_critic2 = -100, -100, -100\n","        if self.memory.max_index >= self.memory.memory_length:\n","          # import pdb; pdb.set_trace()\n","          self.std *= 0.9995\n","          self.std_target *= 0.9995\n","          self.learn_cnt += 1\n","          loss_actor, loss_critic1, loss_critic2 = self.learn()\n","        if done:\n","          break\n","      self.statistic_reward.append(reward_total)\n","      print(', epoch %-4d, total_reward %s, loss_actor = %s, loss_critic1 = %s, loss_critic2 = %s, std = %s' \\\n","            %(i, reward_total, loss_actor, loss_critic1, loss_critic2, self.std))\n","\n","  def replace_soft(self, network_from, network_to, tau=0.01):\n","    for target_param, param in zip(network_to.parameters(), network_from.parameters()):\n","      target_param.data.copy_(\n","        target_param.data * (1.0 - tau) + param.data * tau\n","      )\n","\n","  def learn(self):\n","    state ,action ,reward, next_state = self.memory.sample()\n","    state = torch.from_numpy(state)\n","    action = torch.from_numpy(action)\n","    reward = torch.from_numpy(reward)\n","    next_state = torch.from_numpy(next_state)\n","\n","    next_action = self.actor_network_target.model(next_state).detach()\n","    next_action = torch.clip(torch.normal(next_action, self.std_target), \n","                             self.actor_network.action_bound[0],\n","                             self.actor_network.action_bound[1])\n","    \n","    next_value1 = self.critic_network_target1.model(next_state, next_action).detach()\n","    next_value2 = self.critic_network_target2.model(next_state, next_action).detach()\n","\n","    value_target = reward + self.gamma * torch.min(next_value1, next_value2)\n","\n","    value1 = self.critic_network1.model(state, action)\n","    value2 = self.critic_network2.model(state, action)\n","\n","    loss_critic1 = torch.nn.functional.mse_loss(value1, value_target.detach())\n","    loss_critic2 = torch.nn.functional.mse_loss(value2, value_target.detach())\n","    self.critic_network1.optimizer.zero_grad()\n","    self.critic_network2.optimizer.zero_grad()\n","    loss_critic1.backward()\n","    loss_critic2.backward()\n","    self.critic_network1.optimizer.step()\n","    self.critic_network2.optimizer.step()\n","\n","    loss_actor = torch.Tensor([-100])\n","    \n","    if self.learn_cnt % self.delay == 0:\n","      # import pdb; pdb.set_trace()\n","      action = self.actor_network.model(state)\n","      loss_actor = -torch.mean(self.critic_network1.model(state, action))\n","      self.actor_network.optimizer.zero_grad()\n","      loss_actor.backward()\n","      self.actor_network.optimizer.step()\n","\n","      self.replace_soft(self.critic_network1.model, self.critic_network_target1.model)\n","      self.replace_soft(self.critic_network2.model, self.critic_network_target2.model)\n","      self.replace_soft(self.actor_network.model, self.actor_network_target.model)\n","\n","    return loss_actor.tolist(), loss_critic1.tolist(), loss_critic2.tolist()\n"],"execution_count":66,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"vYy03FbtbqnW"},"source":["![image.png](data:image/png;base64,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)"]},{"cell_type":"code","metadata":{"id":"kFEHz4fGcadm","executionInfo":{"status":"ok","timestamp":1616310778822,"user_tz":-480,"elapsed":1630,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}}},"source":[""],"execution_count":66,"outputs":[]},{"cell_type":"code","metadata":{"id":"dRFlQenVcaKG","colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"status":"error","timestamp":1616310906806,"user_tz":-480,"elapsed":129612,"user":{"displayName":"白梦伟","photoUrl":"","userId":"14318251260292756104"}},"outputId":"95c43cf7-40a2-49b9-c863-0368da02b0a9"},"source":["agent_test = agent_actor_critic()\n","agent_test.start_execute()"],"execution_count":67,"outputs":[{"output_type":"stream","text":[", epoch 0   , total_reward -1284.6300985504142, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 1   , total_reward -1574.3740713089342, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 2   , total_reward -1032.2408600322776, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 3   , total_reward -1037.9008248502992, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 4   , total_reward -1207.5428490570712, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 5   , total_reward -1509.2942803368637, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 6   , total_reward -1399.8495420657575, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 7   , total_reward -1108.1596728902832, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 8   , total_reward -1410.6019557650345, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 9   , total_reward -840.8916915901823, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 10  , total_reward -1114.5165665505056, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 11  , total_reward -1042.4908357767877, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 12  , total_reward -1064.3614346072413, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 13  , total_reward -1270.0324268597037, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 14  , total_reward -1386.2686897026956, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 15  , total_reward -1285.2389687977573, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 16  , total_reward -1163.6056502159413, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 17  , total_reward -1116.3844683215925, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 18  , total_reward -1446.2890852122925, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 19  , total_reward -1130.0798159679625, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 20  , total_reward -1489.8646831415683, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 21  , total_reward -993.9204350185985, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 22  , total_reward -1310.345077706, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 23  , total_reward -1081.1114900726493, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 24  , total_reward -1003.3862836468248, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 25  , total_reward -1403.4436199393936, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 26  , total_reward -1010.820998888038, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 27  , total_reward -1192.735653959258, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 28  , total_reward -1155.2290803377061, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 29  , total_reward -1289.3496154892678, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 30  , total_reward -1187.0018882891043, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 31  , total_reward -1190.9859569683122, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 32  , total_reward -1494.4342779122742, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 33  , total_reward -1142.8864741789678, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 34  , total_reward -1206.5643732771348, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 35  , total_reward -1341.2857441560093, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 36  , total_reward -972.0374362633827, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 37  , total_reward -951.8291356879434, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 38  , total_reward -1312.999777713626, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 39  , total_reward -1341.9431687570282, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 40  , total_reward -999.8643598800674, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 41  , total_reward -1240.7808226430436, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 42  , total_reward -1192.5428828973006, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 43  , total_reward -1272.624316291155, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 44  , total_reward -1539.8660652405372, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 45  , total_reward -1015.7508502033259, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 46  , total_reward -1133.8945904294706, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 47  , total_reward -1448.0581303453403, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 48  , total_reward -1745.7860927923605, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 49  , total_reward -1479.2501189080745, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 50  , total_reward -1301.356690986185, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 51  , total_reward -1330.8136922196754, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 52  , total_reward -1035.5054154617758, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 53  , total_reward -1266.8403975636543, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 54  , total_reward -1216.4270910352263, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 55  , total_reward -1534.4409900610033, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 56  , total_reward -1173.1402074022883, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 57  , total_reward -1650.9919344369916, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 58  , total_reward -1174.9011958696933, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 59  , total_reward -1560.870719285102, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 60  , total_reward -1106.8424892136225, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 61  , total_reward -1046.1776460886213, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 62  , total_reward -1709.4452203907051, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 63  , total_reward -1282.407126239433, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 64  , total_reward -1121.8802691621338, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 65  , total_reward -1083.974302696206, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 66  , total_reward -1180.4114027702583, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 67  , total_reward -862.5331348492664, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 68  , total_reward -1316.4361095008142, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 69  , total_reward -1218.2243671305876, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 70  , total_reward -1170.8079876375152, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 71  , total_reward -1412.0523477824033, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 72  , total_reward -1286.4731924393823, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 73  , total_reward -1490.2162841375782, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 74  , total_reward -1069.5762279262924, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 75  , total_reward -1274.4963545498692, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 76  , total_reward -983.7260946739787, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 77  , total_reward -1207.961679304184, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 78  , total_reward -1197.5004581923463, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 79  , total_reward -1172.0224038605384, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 80  , total_reward -1246.2620468262226, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 81  , total_reward -1000.0651615182435, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 82  , total_reward -1154.703571580953, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 83  , total_reward -1349.5673414373161, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 84  , total_reward -995.8073644305059, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 85  , total_reward -1310.3898418217482, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 86  , total_reward -1182.4935362910858, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 87  , total_reward -1109.6815552598575, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 88  , total_reward -1390.8552886204063, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 89  , total_reward -858.8408606404198, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 90  , total_reward -1406.100845383636, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 91  , total_reward -1297.8046889027905, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 92  , total_reward -1340.2564692799986, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 93  , total_reward -1314.5676730193109, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 94  , total_reward -1020.5713363923952, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 95  , total_reward -1052.7607039599934, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 96  , total_reward -1338.4277737336727, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 97  , total_reward -1060.6126777885388, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 98  , total_reward -1209.1036232243478, loss_actor = -100, loss_critic1 = -100, loss_critic2 = -100, std = 3\n",", epoch 99  , total_reward -1136.7108450978114, loss_actor = [-100.0], loss_critic1 = 55.764352846418966, loss_critic2 = 53.57134434926579, std = 2.9985\n",", epoch 100 , total_reward -1139.0335679612404, loss_actor = 8.40387722620463, loss_critic1 = 6.117002920802353, loss_critic2 = 7.277830389416043, std = 2.713087147336219\n",", epoch 101 , total_reward -1566.9385109308473, loss_actor = [-100.0], loss_critic1 = 0.994688438001099, loss_critic2 = 1.287977795568944, std = 2.454841377035514\n",", epoch 102 , total_reward -1141.1701456029512, loss_actor = [-100.0], loss_critic1 = 0.8423875190933987, loss_critic2 = 1.1098463242780308, std = 2.221176784653723\n",", epoch 103 , total_reward -1707.021412471824, loss_actor = 15.488915921335826, loss_critic1 = 0.5427690671585246, loss_critic2 = 0.5788802829612562, std = 2.0097536056046694\n",", epoch 104 , total_reward -1466.6544041383609, loss_actor = [-100.0], loss_critic1 = 0.2756085985298956, loss_critic2 = 0.303951500358248, std = 1.8184547862860267\n",", epoch 105 , total_reward -1716.538065523218, loss_actor = [-100.0], loss_critic1 = 0.7041853402435498, loss_critic2 = 0.8225002346333787, std = 1.6453647852875282\n",", epoch 106 , total_reward -1561.0429673196015, loss_actor = 25.74951933418417, loss_critic1 = 0.6344384769035827, loss_critic2 = 0.5386671016854239, std = 1.4887503924106082\n",", epoch 107 , total_reward -1781.8454855389286, loss_actor = [-100.0], loss_critic1 = 0.6394002897338354, loss_critic2 = 0.5366410402285934, std = 1.3470433734337053\n",", epoch 108 , total_reward -1587.1584629903668, loss_actor = [-100.0], loss_critic1 = 0.5743967634128594, loss_critic2 = 0.6868818362929636, std = 1.2188247668392234\n",", epoch 109 , total_reward -1372.1402835460835, loss_actor = 33.82095335620628, loss_critic1 = 0.594623794007046, loss_critic2 = 0.8499959346828121, std = 1.1028106752598164\n",", epoch 110 , total_reward -1594.4175768509792, loss_actor = [-100.0], loss_critic1 = 0.427691903769707, loss_critic2 = 0.45090138695988274, std = 0.9978394093688782\n",", epoch 111 , total_reward -1472.9403021398814, loss_actor = [-100.0], loss_critic1 = 1.4951873834286675, loss_critic2 = 1.501670000108651, std = 0.9028598554824963\n",", epoch 112 , total_reward -1568.2550604649289, loss_actor = 34.44482911557763, loss_critic1 = 0.6292384179593684, loss_critic2 = 0.7290878392469557, std = 0.8169209503936613\n",", epoch 113 , total_reward -1122.6288022506974, loss_actor = [-100.0], loss_critic1 = 0.6436064640192888, loss_critic2 = 0.7748322252520701, std = 0.7391621580466001\n",", epoch 114 , total_reward -1539.115098593272, loss_actor = [-100.0], loss_critic1 = 0.5915628913542567, loss_critic2 = 0.6524242882605011, std = 0.6688048526908563\n",", epoch 115 , total_reward -1163.3010672835624, loss_actor = 36.22692929309902, loss_critic1 = 0.5324906168088828, loss_critic2 = 0.4771213920376729, std = 0.6051445222316677\n",", epoch 116 , total_reward -1107.231913653389, loss_actor = [-100.0], loss_critic1 = 0.9171420755452218, loss_critic2 = 0.7223199223307463, std = 0.5475437137060705\n",", epoch 117 , total_reward -1058.8355424309773, loss_actor = [-100.0], loss_critic1 = 1.2245957381734809, loss_critic2 = 0.8805159963301875, std = 0.4954256502453501\n",", epoch 118 , total_reward -1064.006652144072, loss_actor = 43.11593198340604, loss_critic1 = 1.490497762414822, loss_critic2 = 1.4919289167755632, std = 0.44826845560825324\n",", epoch 119 , total_reward -1065.9580707623952, loss_actor = [-100.0], loss_critic1 = 1.0309341844512212, loss_critic2 = 1.1873171863912486, std = 0.40559992845322906\n",", epoch 120 , total_reward -935.2976342075976, loss_actor = [-100.0], loss_critic1 = 0.36182214907545995, loss_critic2 = 0.35406442148125594, std = 0.3669928140226599\n",", epoch 121 , total_reward -937.0629963671846, loss_actor = 44.12058739482078, loss_critic1 = 0.9535170175396899, loss_critic2 = 0.8467059950599954, std = 0.33206052589282303\n",", epoch 122 , total_reward -832.8019390324115, loss_actor = [-100.0], loss_critic1 = 0.7947988553798192, loss_critic2 = 0.8708509309084163, std = 0.30045327494998236\n",", epoch 123 , total_reward -851.1965373931679, loss_actor = [-100.0], loss_critic1 = 0.958946019491215, loss_critic2 = 0.726695379138929, std = 0.27185456683070613\n",", epoch 124 , total_reward -803.101978837577, loss_actor = 53.12938203116633, loss_critic1 = 1.5469413692177212, loss_critic2 = 1.4248872095746368, std = 0.24597803275405816\n",", epoch 125 , total_reward -595.4065970517228, loss_actor = [-100.0], loss_critic1 = 0.6607172362354903, loss_critic2 = 0.6149221931185955, std = 0.22256456201169997\n",", epoch 126 , total_reward -982.3995020830046, loss_actor = [-100.0], loss_critic1 = 1.0394059487528708, loss_critic2 = 0.9777304640302669, std = 0.20137970740252054\n",", epoch 127 , total_reward -812.0749711385694, loss_actor = 52.631841355915036, loss_critic1 = 0.9979239171314843, loss_critic2 = 0.707269256265267, std = 0.18221133763151806\n",", epoch 128 , total_reward -1057.2765741090084, loss_actor = [-100.0], loss_critic1 = 0.8814472136498864, loss_critic2 = 0.673942780760171, std = 0.16486751316558673\n",", epoch 129 , total_reward -1211.9765669437452, loss_actor = [-100.0], loss_critic1 = 0.7471057227070683, loss_critic2 = 0.4108799131012638, std = 0.1491745642764176\n",", epoch 130 , total_reward -941.0350255051496, loss_actor = 49.87411790140345, loss_critic1 = 0.7638160717208518, loss_critic2 = 0.5813117526438598, std = 0.13497535202528893\n",", epoch 131 , total_reward -953.9427446004106, loss_actor = [-100.0], loss_critic1 = 0.7084046240331453, loss_critic2 = 0.6000322542143974, std = 0.12212769477638576\n",", epoch 132 , total_reward -128.53211748410024, loss_actor = [-100.0], loss_critic1 = 1.2436468912129712, loss_critic2 = 1.0689367242938854, std = 0.11050294448277907\n",", epoch 133 , total_reward -852.5078439287308, loss_actor = 47.05220962159801, loss_critic1 = 1.7251444332574517, loss_critic2 = 1.627424112324986, std = 0.09998469848892297\n",", epoch 134 , total_reward -838.2531125357756, loss_actor = [-100.0], loss_critic1 = 0.5176226052568507, loss_critic2 = 0.4440802919172456, std = 0.09046763395050325\n",", epoch 135 , total_reward -653.5793570303922, loss_actor = [-100.0], loss_critic1 = 1.0521234442951894, loss_critic2 = 0.6414818863960002, std = 0.0818564532002761\n",", epoch 136 , total_reward -511.8233363209794, loss_actor = 50.25393733749473, loss_critic1 = 0.8241712225751392, loss_critic2 = 0.6809667090509298, std = 0.07406492949948229\n",", epoch 137 , total_reward -270.31936866249623, loss_actor = [-100.0], loss_critic1 = 0.5243177807312873, loss_critic2 = 0.44755938720289545, std = 0.06701504361961268\n",", epoch 138 , total_reward -406.6154702189384, loss_actor = [-100.0], loss_critic1 = 0.63034797599649, loss_critic2 = 0.5858745360331088, std = 0.06063620260882013\n",", epoch 139 , total_reward -266.33363942695195, loss_actor = 50.6793352137001, loss_critic1 = 1.0675192415820454, loss_critic2 = 0.8206738624037999, std = 0.054864532920214974\n",", epoch 140 , total_reward -144.70613189186057, loss_actor = [-100.0], loss_critic1 = 1.127291053140113, loss_critic2 = 0.6383206981117419, std = 0.049642240823891945\n",", epoch 141 , total_reward -272.9230589374178, loss_actor = [-100.0], loss_critic1 = 0.5427398148045621, loss_critic2 = 0.5174815457655996, std = 0.04491703369827259\n",", epoch 142 , total_reward -301.0918800612551, loss_actor = 51.23348098051913, loss_critic1 = 1.0473773261621986, loss_critic2 = 0.920786240669393, std = 0.040641596405953356\n",", epoch 143 , total_reward -8.003842387157839, loss_actor = [-100.0], loss_critic1 = 1.0601804821290304, loss_critic2 = 0.9030283960227896, std = 0.03677311751082805\n",", epoch 144 , total_reward -139.6958862496745, loss_actor = [-100.0], loss_critic1 = 0.7261849683066954, loss_critic2 = 0.9761982231257268, std = 0.03327286059233351\n",", epoch 145 , total_reward -268.019814561582, loss_actor = 52.00071741347975, loss_critic1 = 0.40289241490410144, loss_critic2 = 0.497192073007116, std = 0.030105776364238696\n",", epoch 146 , total_reward -371.65331547750014, loss_actor = [-100.0], loss_critic1 = 0.35647000399150486, loss_critic2 = 0.37227987609829755, std = 0.027240151713988497\n",", epoch 147 , total_reward -329.1654774583358, loss_actor = [-100.0], loss_critic1 = 1.44937985352805, loss_critic2 = 1.0008549650464342, std = 0.024647292148311118\n",", epoch 148 , total_reward -269.2508757778098, loss_actor = 46.23866828892663, loss_critic1 = 1.206428421244484, loss_critic2 = 0.860946617536906, std = 0.02230123446530724\n",", epoch 149 , total_reward -301.0266525486723, loss_actor = [-100.0], loss_critic1 = 0.7817076432201638, loss_critic2 = 0.5236762718758103, std = 0.0201784867759068\n",", epoch 150 , total_reward -141.58951425980172, loss_actor = [-100.0], loss_critic1 = 0.90691872063089, loss_critic2 = 0.5525716890930259, std = 0.018257793271437884\n",", epoch 151 , total_reward -260.23371291095, loss_actor = 43.67958278255011, loss_critic1 = 1.0038084442117607, loss_critic2 = 0.6559789751801883, std = 0.016519921381844202\n",", epoch 152 , total_reward -139.90566464513748, loss_actor = [-100.0], loss_critic1 = 0.9411007345116271, loss_critic2 = 0.8146087891473794, std = 0.014947469193292071\n",", epoch 153 , total_reward -3.0675612240278882, loss_actor = [-100.0], loss_critic1 = 0.7617993646023932, loss_critic2 = 0.285844013203838, std = 0.01352469119677332\n",", epoch 154 , total_reward -131.04122877647606, loss_actor = 44.291377759799595, loss_critic1 = 0.6284344257416267, loss_critic2 = 0.7420124744279869, std = 0.012237340622863758\n",", epoch 155 , total_reward -136.32256760833832, loss_actor = [-100.0], loss_critic1 = 0.7344987177151354, loss_critic2 = 0.6341412882305004, std = 0.011072526783880954\n",", epoch 156 , total_reward -127.35348567507394, loss_actor = [-100.0], loss_critic1 = 0.47322296430345984, loss_critic2 = 0.48081108504226955, std = 0.010018585994958635\n",", epoch 157 , total_reward -127.19790442426479, loss_actor = 42.177922153487245, loss_critic1 = 0.3218488305026439, loss_critic2 = 0.34160369753533104, std = 0.009064964781525731\n",", epoch 158 , total_reward -137.07402896957797, loss_actor = [-100.0], loss_critic1 = 1.3837054382219012, loss_critic2 = 0.9579720004272995, std = 0.008202114203706168\n",", epoch 159 , total_reward -275.05932814580086, loss_actor = [-100.0], loss_critic1 = 0.6807189947266538, loss_critic2 = 0.5556268430832805, std = 0.0074213942394727546\n",", epoch 160 , total_reward -130.46847617349405, loss_actor = 41.88106172901042, loss_critic1 = 0.9913289456352785, loss_critic2 = 0.8954392914694512, std = 0.006714987269110753\n",", epoch 161 , total_reward -353.1089266501866, loss_actor = [-100.0], loss_critic1 = 0.4007823790697485, loss_critic2 = 0.41064726895541764, std = 0.00607581979468091\n",", epoch 162 , total_reward -137.8564266179997, loss_actor = [-100.0], loss_critic1 = 0.5973978064042058, loss_critic2 = 0.552491090366203, std = 0.005497491610631904\n",", epoch 163 , total_reward -254.02333308963665, loss_actor = 49.33166144113157, loss_critic1 = 0.42937340173699773, loss_critic2 = 0.38896586099015473, std = 0.004974211716322864\n",", epoch 164 , total_reward -367.0733963761194, loss_actor = [-100.0], loss_critic1 = 0.5565886203418728, loss_critic2 = 0.3676949880639207, std = 0.004500740328725962\n",", epoch 165 , total_reward -3.2869915547345117, loss_actor = [-100.0], loss_critic1 = 0.6654736807194964, loss_critic2 = 0.4404797616217718, std = 0.004072336414662055\n",", epoch 166 , total_reward -132.61900814674237, loss_actor = 47.18703045284427, loss_critic1 = 0.7566610890968974, loss_critic2 = 0.6121827094362503, std = 0.0036847102171915563\n",", epoch 167 , total_reward -0.3982574910815452, loss_actor = [-100.0], loss_critic1 = 0.2805299607519461, loss_critic2 = 0.34421086682831215, std = 0.0033339803007906813\n",", epoch 168 , total_reward -135.27331163296432, loss_actor = [-100.0], loss_critic1 = 0.6024243025448204, loss_critic2 = 0.5101018641847554, std = 0.0030166346851917087\n",", epoch 169 , total_reward -133.37867932485875, loss_actor = 45.61813822187078, loss_critic1 = 0.6658839587933345, loss_critic2 = 0.8032657919001048, std = 0.0027294956787067754\n",", epoch 170 , total_reward -0.37157971360529574, loss_actor = [-100.0], loss_critic1 = 0.6518866383703736, loss_critic2 = 0.47407170475597843, std = 0.0024696880588991493\n",", epoch 171 , total_reward -257.25307678272645, loss_actor = [-100.0], loss_critic1 = 0.5389626327051712, loss_critic2 = 0.37897695919035856, std = 0.0022346102819839966\n",", epoch 172 , total_reward -130.46414014189395, loss_actor = 33.00362571559303, loss_critic1 = 0.19356954307551638, loss_critic2 = 0.16209153934555964, std = 0.0020219084326683822\n",", epoch 173 , total_reward -244.13002435332317, loss_actor = [-100.0], loss_critic1 = 0.6467512259385781, loss_critic2 = 0.6124536487422576, std = 0.0018294526535812252\n",", epoch 174 , total_reward -134.7081350033228, loss_actor = [-100.0], loss_critic1 = 0.2795263085146741, loss_critic2 = 0.308999555486502, std = 0.0016553158182729232\n",", epoch 175 , total_reward -402.5517362559539, loss_actor = 25.313579042289458, loss_critic1 = 0.23960526818255456, loss_critic2 = 0.24995780242309434, std = 0.0014977542342299848\n",", epoch 176 , total_reward -132.9091885641481, loss_actor = [-100.0], loss_critic1 = 0.29189458896157006, loss_critic2 = 0.3832852085642961, std = 0.0013551901826772618\n",", epoch 177 , total_reward -1.1749859594782694, loss_actor = [-100.0], loss_critic1 = 0.3068241553441228, loss_critic2 = 0.3614360306327449, std = 0.0012261961203327994\n",", epoch 178 , total_reward -269.40319473507907, loss_actor = 33.83471221054574, loss_critic1 = 0.3318330606572785, loss_critic2 = 0.431040455720606, std = 0.0011094803849219462\n",", epoch 179 , total_reward -138.42549518393008, loss_actor = [-100.0], loss_critic1 = 0.46116133687482275, loss_critic2 = 0.41520971395747036, std = 0.0010038742613151146\n",", epoch 180 , total_reward -127.83028452948015, loss_actor = [-100.0], loss_critic1 = 0.301824340822803, loss_critic2 = 0.22852859355787825, std = 0.0009083202787779479\n",", epoch 181 , total_reward -257.29939652439197, loss_actor = 26.219933083184607, loss_critic1 = 0.2080295549249358, loss_critic2 = 0.30442640462662296, std = 0.0008218616221501757\n",", epoch 182 , total_reward -131.45138048053693, loss_actor = [-100.0], loss_critic1 = 0.27740885665623977, loss_critic2 = 0.11025128520928919, std = 0.0007436325509236411\n",", epoch 183 , total_reward -131.18609890297782, loss_actor = [-100.0], loss_critic1 = 0.2553262982381559, loss_critic2 = 0.19259286655654595, std = 0.0006728497302824\n",", epoch 184 , total_reward -130.87363937788498, loss_actor = 26.517883148919953, loss_critic1 = 0.2979947394536926, loss_critic2 = 0.14450157864206695, std = 0.0006088043872995889\n",", epoch 185 , total_reward -366.82692521794417, loss_actor = [-100.0], loss_critic1 = 0.8467741623950249, loss_critic2 = 1.3599135125235446, std = 0.0005508552137483458\n",", epoch 186 , total_reward -139.2043431847144, loss_actor = [-100.0], loss_critic1 = 0.2089984056573392, loss_critic2 = 0.20452833210468774, std = 0.0004984219444601573\n",", epoch 187 , total_reward -2.8221196766953716, loss_actor = 22.913764439836505, loss_critic1 = 0.1293259431764679, loss_critic2 = 0.23166632259275266, std = 0.00045097954692852364\n",", epoch 188 , total_reward -141.139997555191, loss_actor = [-100.0], loss_critic1 = 0.190958727319158, loss_critic2 = 0.1876621714501059, std = 0.00040805296397641746\n",", epoch 189 , total_reward -137.02861233392804, loss_actor = [-100.0], loss_critic1 = 0.6686344718179971, loss_critic2 = 0.48489050733049266, std = 0.0003692123568440443\n",", epoch 190 , total_reward -398.111959119972, loss_actor = 36.05017028260906, loss_critic1 = 0.40653584377149077, loss_critic2 = 0.3913953761381823, std = 0.00033406880106429555\n",", epoch 191 , total_reward -2.7707360244571855, loss_actor = [-100.0], loss_critic1 = 0.39251585253218124, loss_critic2 = 0.4392334052133998, std = 0.00030227039202720014\n",", epoch 192 , total_reward -134.7467806318675, loss_actor = [-100.0], loss_critic1 = 0.34143780961187553, loss_critic2 = 0.2033608603462772, std = 0.00027349872123704405\n",", epoch 193 , total_reward -130.33369242113264, loss_actor = 18.201186969778647, loss_critic1 = 0.26287902015417475, loss_critic2 = 0.3017689181477747, std = 0.0002474656879776938\n",", epoch 194 , total_reward -128.01494793126346, loss_actor = [-100.0], loss_critic1 = 0.07373305893498165, loss_critic2 = 0.13136922186298147, std = 0.00022391061446022867\n",", epoch 195 , total_reward -1.8092440127646738, loss_actor = [-100.0], loss_critic1 = 0.20128091925537306, loss_critic2 = 0.22430604742986626, std = 0.00020259763556585014\n",", epoch 196 , total_reward -2.4279902280048056, loss_actor = 21.864373638153697, loss_critic1 = 0.3884015992191438, loss_critic2 = 0.8555959377033426, std = 0.00018331333704666155\n",", epoch 197 , total_reward -129.6729450364374, loss_actor = [-100.0], loss_critic1 = 0.18743530165282074, loss_critic2 = 0.24124988104681722, std = 0.00016586461853480386\n",", epoch 198 , total_reward -125.11039975213608, loss_actor = [-100.0], loss_critic1 = 0.14295168255596521, loss_critic2 = 0.16647489069688495, std = 0.00015007675996151444\n",", epoch 199 , total_reward -128.22343591191367, loss_actor = 20.768860774821217, loss_critic1 = 0.09889073929638405, loss_critic2 = 0.13038602555554304, std = 0.00013579167202449477\n",", epoch 200 , total_reward -136.69075708701777, loss_actor = [-100.0], loss_critic1 = 0.22295011661834807, loss_critic2 = 0.17439607420289552, std = 0.00012286631318490977\n",", epoch 201 , total_reward -2.6669688542527523, loss_actor = [-100.0], loss_critic1 = 0.11962457885900915, loss_critic2 = 0.1186092221149099, std = 0.00011117125734285985\n",", epoch 202 , total_reward -1.7190944645705253, loss_actor = 26.06317058510881, loss_critic1 = 0.1142045580854407, loss_critic2 = 0.06739182638073579, std = 0.00010058939784896461\n",", epoch 203 , total_reward -0.3659779537721369, loss_actor = [-100.0], loss_critic1 = 0.14457328654036553, loss_critic2 = 0.14367364569913457, std = 9.101477487487585e-05\n",", epoch 204 , total_reward -275.20313074807717, loss_actor = [-100.0], loss_critic1 = 0.16247102847692152, loss_critic2 = 0.143461707897081, std = 8.235151440077536e-05\n",", epoch 205 , total_reward -129.35003387613898, loss_actor = 16.989685338994303, loss_critic1 = 0.11938102795916096, loss_critic2 = 0.12861926442240249, std = 7.451286819557016e-05\n",", epoch 206 , total_reward -244.29945679939968, loss_actor = [-100.0], loss_critic1 = 0.0813149005879649, loss_critic2 = 0.11418498731512407, std = 6.742034517677467e-05\n",", epoch 207 , total_reward -129.62879017423333, loss_actor = [-100.0], loss_critic1 = 0.1396066344245429, loss_critic2 = 0.11593934141280418, std = 6.100292545208564e-05\n",", epoch 208 , total_reward -127.0560343598567, loss_actor = 20.343883481998493, loss_critic1 = 0.10307170168032576, loss_critic2 = 0.10190175384280557, std = 5.519634917257397e-05\n",", epoch 209 , total_reward -135.5298038167139, loss_actor = [-100.0], loss_critic1 = 0.21251134299570157, loss_critic2 = 0.14482667252805873, std = 4.994247307653571e-05\n",", epoch 210 , total_reward -352.1737036494822, loss_actor = [-100.0], loss_critic1 = 0.20053012537365306, loss_critic2 = 0.30345375509110656, std = 4.5188688280851775e-05\n",", epoch 211 , total_reward -258.82789639267975, loss_actor = 12.526741187417416, loss_critic1 = 0.0760135843236347, loss_critic2 = 0.06655412077958538, std = 4.088739348999887e-05\n",", epoch 212 , total_reward -136.5924586228288, loss_actor = [-100.0], loss_critic1 = 0.13665249843419897, loss_critic2 = 0.16111014819256042, std = 3.699551834777207e-05\n",", epoch 213 , total_reward -137.46983961285486, loss_actor = [-100.0], loss_critic1 = 0.08457867729025276, loss_critic2 = 0.11182747853774498, std = 3.347409215887334e-05\n",", epoch 214 , total_reward -132.44583174457333, loss_actor = 22.300999155923787, loss_critic1 = 0.13395874691478463, loss_critic2 = 0.227011331986551, std = 3.02878536618267e-05\n",", epoch 215 , total_reward -133.83568134406633, loss_actor = [-100.0], loss_critic1 = 0.18471224540736392, loss_critic2 = 0.17206069414536068, std = 2.7404897945740283e-05\n",", epoch 216 , total_reward -251.96626822335213, loss_actor = [-100.0], loss_critic1 = 0.15296800851382292, loss_critic2 = 0.13047621008129154, std = 2.4796356975370577e-05\n",", epoch 217 , total_reward -247.10082219665216, loss_actor = 11.306914183151294, loss_critic1 = 0.052723712726977345, loss_critic2 = 0.030867265375572925, std = 2.2436110525475626e-05\n",", epoch 218 , total_reward -269.3705870439421, loss_actor = [-100.0], loss_critic1 = 0.05695587431645244, loss_critic2 = 0.13742160634343548, std = 2.030052462994253e-05\n",", epoch 219 , total_reward -133.82282405758085, loss_actor = [-100.0], loss_critic1 = 0.09880627407952647, loss_critic2 = 0.1662212901386505, std = 1.8368214926689826e-05\n",", epoch 220 , total_reward -134.94236170983098, loss_actor = 9.936294753691463, loss_critic1 = 0.045981313088854815, loss_critic2 = 0.06660967744711022, std = 1.6619832528634784e-05\n",", epoch 221 , total_reward -139.63315248662056, loss_actor = [-100.0], loss_critic1 = 0.08814937740577196, loss_critic2 = 0.18739079973791936, std = 1.5037870276578062e-05\n",", epoch 222 , total_reward -131.1894198738607, loss_actor = [-100.0], loss_critic1 = 0.3920659777407277, loss_critic2 = 0.24219382784106794, std = 1.360648743394807e-05\n",", epoch 223 , total_reward -244.79375967040252, loss_actor = 11.394633532833488, loss_critic1 = 0.10083572811044167, loss_critic2 = 0.7419978418003162, std = 1.231135106801275e-05\n",", epoch 224 , total_reward -138.9032272573714, loss_actor = [-100.0], loss_critic1 = 0.027305272574021672, loss_critic2 = 0.04226523023966351, std = 1.1139492529254434e-05\n",", epoch 225 , total_reward -141.0313807831932, loss_actor = [-100.0], loss_critic1 = 0.03556107548729068, loss_critic2 = 0.05681062077416378, std = 1.0079177591785227e-05\n",", epoch 226 , total_reward -138.52869382560556, loss_actor = 11.051311984297321, loss_critic1 = 0.434131272074027, loss_critic2 = 0.6035038497724157, std = 9.119788954474461e-06\n",", epoch 227 , total_reward -135.77594154518718, loss_actor = [-100.0], loss_critic1 = 0.01779161768340385, loss_critic2 = 0.046063408379681474, std = 8.251719926230929e-06\n",", epoch 228 , total_reward -264.47666750667725, loss_actor = [-100.0], loss_critic1 = 0.12147553914215536, loss_critic2 = 0.08531879037521392, std = 7.466278230873862e-06\n",", epoch 229 , total_reward -263.27881619093006, loss_actor = 4.770670851651106, loss_critic1 = 0.03093572379522486, loss_critic2 = 0.03439491389435648, std = 6.755598968357539e-06\n",", epoch 230 , total_reward -15.957362825752833, loss_actor = [-100.0], loss_critic1 = 0.07578525294033207, loss_critic2 = 0.08249768788260416, std = 6.1125658607999455e-06\n",", epoch 231 , total_reward -277.3766855645177, loss_actor = [-100.0], loss_critic1 = 0.2187306164405614, loss_critic2 = 0.12817399937891788, std = 5.5307399947248555e-06\n",", epoch 232 , total_reward -373.8035200566278, loss_actor = 8.939644228852234, loss_critic1 = 0.03149767342350988, loss_critic2 = 0.03568109416460558, std = 5.004295345988457e-06\n",", epoch 233 , total_reward -136.16282645980868, loss_actor = [-100.0], loss_critic1 = 0.04214563392594939, loss_critic2 = 0.11886885507815884, std = 4.527960441779468e-06\n",", epoch 234 , total_reward -134.25957804262677, loss_actor = [-100.0], loss_critic1 = 0.09255332475482493, loss_critic2 = 0.03821030136654416, std = 4.096965575534e-06\n",", epoch 235 , total_reward -140.59348476873095, loss_actor = 2.0739765927774654, loss_critic1 = 0.055916869545734424, loss_critic2 = 0.045732060482224904, std = 3.706995046209844e-06\n",", epoch 236 , total_reward -274.90389409278623, loss_actor = [-100.0], loss_critic1 = 0.04543594747495141, loss_critic2 = 0.06014212298946082, std = 3.3541439436754864e-06\n",", epoch 237 , total_reward -138.24977330579478, loss_actor = [-100.0], loss_critic1 = 0.04585220055004139, loss_critic2 = 0.07188057660411336, std = 3.0348790474909342e-06\n",", epoch 238 , total_reward -12.359153845639183, loss_actor = 10.031471336023227, loss_critic1 = 0.08567679256924314, loss_critic2 = 0.14060589389201988, std = 2.7460034475463197e-06\n",", epoch 239 , total_reward -272.6912810198315, loss_actor = [-100.0], loss_critic1 = 0.0458662640839202, loss_critic2 = 0.04956414919291418, std = 2.484624532292434e-06\n",", epoch 240 , total_reward -258.0416966971521, loss_actor = [-100.0], loss_critic1 = 0.11425643863783516, loss_critic2 = 0.04888238551330467, std = 2.248125024018298e-06\n",", epoch 241 , total_reward -299.2059465184255, loss_actor = 6.704061587537118, loss_critic1 = 0.12075111168191224, loss_critic2 = 0.028155407072269885, std = 2.034136771141896e-06\n",", epoch 242 , total_reward -136.8312608113575, loss_actor = [-100.0], loss_critic1 = 0.0357918717509448, loss_critic2 = 0.0550181169410033, std = 1.8405170350872356e-06\n",", epoch 243 , total_reward -142.31411118021836, loss_actor = [-100.0], loss_critic1 = 0.07044915317782664, loss_critic2 = 0.04880639071991899, std = 1.6653270342999983e-06\n",", epoch 244 , total_reward -141.28161481555358, loss_actor = 5.926767895949582, loss_critic1 = 0.01443150251783968, loss_critic2 = 0.015654246157069104, std = 1.5068125305555654e-06\n",", epoch 245 , total_reward -250.28738815847544, loss_actor = [-100.0], loss_critic1 = 0.0045446658227725235, loss_critic2 = 0.010507584832847599, std = 1.3633862631634036e-06\n",", epoch 246 , total_reward -134.56475551341947, loss_actor = [-100.0], loss_critic1 = 0.05934568869639364, loss_critic2 = 0.04731445733549715, std = 1.233612055175382e-06\n",", epoch 247 , total_reward -137.44071478987593, loss_actor = 7.841955841238995, loss_critic1 = 0.07468397440042203, loss_critic2 = 0.04487241395511402, std = 1.1161904324480068e-06\n",", epoch 248 , total_reward -251.30745137799897, loss_actor = [-100.0], loss_critic1 = 0.021380596449747165, loss_critic2 = 0.03121849739406528, std = 1.0099456115572257e-06\n",", epoch 249 , total_reward -133.7197900053584, loss_actor = [-100.0], loss_critic1 = 0.0314896190176195, loss_critic2 = 0.03950890798527352, std = 9.1381372627131e-07\n",", epoch 250 , total_reward -371.05399837192584, loss_actor = 3.863578703591692, loss_critic1 = 0.0460181512193076, loss_critic2 = 0.06916927799740612, std = 8.268321746893808e-07\n",", epoch 251 , total_reward -130.72995628453026, loss_actor = [-100.0], loss_critic1 = 0.00699725545179976, loss_critic2 = 0.0041570069647948425, std = 7.481299803747913e-07\n",", epoch 252 , total_reward -250.3866514238225, loss_actor = [-100.0], loss_critic1 = 0.0133483880254745, loss_critic2 = 0.07891419036865721, std = 6.769190709660642e-07\n",", epoch 253 , total_reward -132.20300601912933, loss_actor = 4.816954071269933, loss_critic1 = 0.18857434510155457, loss_critic2 = 0.07617580184956844, std = 6.124863869350683e-07\n",", epoch 254 , total_reward -240.85681524796422, loss_actor = [-100.0], loss_critic1 = 0.02556685683101574, loss_critic2 = 0.014916585392257323, std = 5.541867414747139e-07\n",", epoch 255 , total_reward -130.71163887924956, loss_actor = [-100.0], loss_critic1 = 0.05267887170793164, loss_critic2 = 0.021437003723515174, std = 5.014363600197384e-07\n",", epoch 256 , total_reward -385.8713930778822, loss_actor = 10.503137651058244, loss_critic1 = 0.10113203959477006, loss_critic2 = 0.0832055154593734, std = 4.537070347095573e-07\n",", epoch 257 , total_reward -140.8411915322627, loss_actor = [-100.0], loss_critic1 = 0.013928700723267982, loss_critic2 = 0.02698259051596104, std = 4.105208352598061e-07\n",", epoch 258 , total_reward -539.684583905009, loss_actor = [-100.0], loss_critic1 = 0.07441976671367752, loss_critic2 = 0.04554606941374444, std = 3.714453232806764e-07\n",", epoch 259 , total_reward -275.42772024388495, loss_actor = 10.934863419016715, loss_critic1 = 0.07540253431692222, loss_critic2 = 0.04546679142110684, std = 3.360892221213774e-07\n",", epoch 260 , total_reward -141.53569017522346, loss_actor = [-100.0], loss_critic1 = 0.15880652626679306, loss_critic2 = 0.07959134330271975, std = 3.040984988813526e-07\n",", epoch 261 , total_reward -11.078550785109796, loss_actor = [-100.0], loss_critic1 = 0.03279854068889429, loss_critic2 = 0.039876299706842845, std = 2.7515281935608956e-07\n",", epoch 262 , total_reward -136.2114517987106, loss_actor = 5.670952020835531, loss_critic1 = 0.10387651233827264, loss_critic2 = 0.09120550491700286, std = 2.489623404196532e-07\n",", epoch 263 , total_reward -140.77890084264519, loss_actor = [-100.0], loss_critic1 = 0.10879096575724655, loss_critic2 = 0.014497215532495309, std = 2.252648077249641e-07\n",", epoch 264 , total_reward -137.54797220012733, loss_actor = [-100.0], loss_critic1 = 0.059347078457372124, loss_critic2 = 0.01003450595809911, std = 2.0382292966008485e-07\n",", epoch 265 , total_reward -10.119968764980092, loss_actor = 7.878543005228693, loss_critic1 = 0.04836216847828278, loss_critic2 = 0.05384735091095542, std = 1.8442200126502924e-07\n",", epoch 266 , total_reward -139.95934981031007, loss_actor = [-100.0], loss_critic1 = 0.12537314438258731, loss_critic2 = 0.05449381269975377, std = 1.6686775431654978e-07\n",", epoch 267 , total_reward -288.6300221619551, loss_actor = [-100.0], loss_critic1 = 0.13008714696195775, loss_critic2 = 0.0927833627280107, std = 1.5098441205305627e-07\n",", epoch 268 , total_reward -401.2775468769453, loss_actor = 8.186193879933573, loss_critic1 = 0.10087724913271515, loss_critic2 = 0.056340248989154566, std = 1.366129290609515e-07\n",", epoch 269 , total_reward -286.9983867113173, loss_actor = [-100.0], loss_critic1 = 0.04220242983365461, loss_critic2 = 0.05389985345444957, std = 1.2360939869775606e-07\n",", epoch 270 , total_reward -391.7964729358491, loss_actor = [-100.0], loss_critic1 = 0.1770037469260184, loss_critic2 = 0.04838484021010196, std = 1.1184361210499928e-07\n",", epoch 271 , total_reward -269.8225680033012, loss_actor = 8.812775919692012, loss_critic1 = 0.08821913839600337, loss_critic2 = 0.04999563336515514, std = 1.0119775438176783e-07\n",", epoch 272 , total_reward -256.71802952393364, loss_actor = [-100.0], loss_critic1 = 0.03392622578589922, loss_critic2 = 0.033676714004998345, std = 9.156522486325215e-08\n",", epoch 273 , total_reward -131.38983336156258, loss_actor = [-100.0], loss_critic1 = 0.0714952146280948, loss_critic2 = 0.08164760735736942, std = 8.284956969132574e-08\n",", epoch 274 , total_reward -395.66057586440104, loss_actor = 5.353519880710582, loss_critic1 = 0.061437931002472204, loss_critic2 = 0.08980387485224293, std = 7.496351598861831e-08\n",", epoch 275 , total_reward -282.86735092322846, loss_actor = [-100.0], loss_critic1 = 0.02053546856070065, loss_critic2 = 0.024261059803050617, std = 6.782809796493365e-08\n",", epoch 276 , total_reward -139.92936948006633, loss_actor = [-100.0], loss_critic1 = 0.02890933426027955, loss_critic2 = 0.032929056110803503, std = 6.137186620541042e-08\n",", epoch 277 , total_reward -137.4031944519747, loss_actor = 7.048572271037066, loss_critic1 = 0.07036435967828582, loss_critic2 = 0.0811811088543701, std = 5.553017222275695e-08\n",", epoch 278 , total_reward -378.78650478225114, loss_actor = [-100.0], loss_critic1 = 0.021748069367394235, loss_critic2 = 0.04253332698298615, std = 5.024452110953095e-08\n",", epoch 279 , total_reward -303.9706657534703, loss_actor = [-100.0], loss_critic1 = 0.10669361942118975, loss_critic2 = 0.05543825625374377, std = 4.54619858083481e-08\n",", epoch 280 , total_reward -399.458599529697, loss_actor = 6.14961268247899, loss_critic1 = 0.07017641265495436, loss_critic2 = 0.039555472944991545, std = 4.113467713490437e-08\n",", epoch 281 , total_reward -339.8051699692498, loss_actor = [-100.0], loss_critic1 = 0.034106162080731715, loss_critic2 = 0.05326425945806349, std = 3.721926424696814e-08\n",", epoch 282 , total_reward -274.866722953611, loss_actor = [-100.0], loss_critic1 = 0.023389738184831275, loss_critic2 = 0.02734692501508021, std = 3.367654075763204e-08\n",", epoch 283 , total_reward -392.3611147664308, loss_actor = 20.357739138217507, loss_critic1 = 0.10598934170881044, loss_critic2 = 0.0957754187689607, std = 3.0471032148165987e-08\n",", epoch 284 , total_reward -275.4463728925831, loss_actor = [-100.0], loss_critic1 = 0.037516212668982515, loss_critic2 = 0.05411605539472329, std = 2.757064054936061e-08\n",", epoch 285 , total_reward -270.24968406673736, loss_actor = [-100.0], loss_critic1 = 0.034453782860802265, loss_critic2 = 0.04410443038046042, std = 2.4946323334432894e-08\n",", epoch 286 , total_reward -135.41593360456145, loss_actor = 3.977172475270074, loss_critic1 = 0.039275803461851055, loss_critic2 = 0.04343131988845581, std = 2.2571802305133705e-08\n",", epoch 287 , total_reward -261.0900833656517, loss_actor = [-100.0], loss_critic1 = 0.06849870283418014, loss_critic2 = 0.09008623856760328, std = 2.0423300559036934e-08\n",", epoch 288 , total_reward -137.53918773129357, loss_actor = [-100.0], loss_critic1 = 0.09396942928498794, loss_critic2 = 0.05642770175782123, std = 1.8479304403170825e-08\n",", epoch 289 , total_reward -381.89843009855804, loss_actor = 11.319512128356791, loss_critic1 = 0.019652446748378544, loss_critic2 = 0.05940156256498259, std = 1.6720347929950443e-08\n",", epoch 290 , total_reward -7.893257554889196, loss_actor = [-100.0], loss_critic1 = 0.061355185451560615, loss_critic2 = 0.037763300400965844, std = 1.5128818098295253e-08\n",", epoch 291 , total_reward -397.3580831006779, loss_actor = [-100.0], loss_critic1 = 0.04374038687372963, loss_critic2 = 0.1376131600420115, std = 1.3688778368141549e-08\n",", epoch 292 , total_reward -140.1311178088745, loss_actor = 6.808168399882056, loss_critic1 = 0.0936113192851046, loss_critic2 = 0.051164279814887074, std = 1.2385809122340791e-08\n",", epoch 293 , total_reward -8.150842564187014, loss_actor = [-100.0], loss_critic1 = 0.031051117125344363, loss_critic2 = 0.039938594503528865, std = 1.1206863278033168e-08\n",", epoch 294 , total_reward -10.978469433818049, loss_actor = [-100.0], loss_critic1 = 0.02771478869647747, loss_critic2 = 0.035294962538872786, std = 1.0140135641682856e-08\n",", epoch 295 , total_reward -421.2590856344154, loss_actor = 10.740345891404, loss_critic1 = 0.07947172348856399, loss_critic2 = 0.05054194834200396, std = 9.174944699581682e-09\n",", epoch 296 , total_reward -137.74450231718362, loss_actor = [-100.0], loss_critic1 = 0.03490570338463845, loss_critic2 = 0.019993430369823352, std = 8.301625660148602e-09\n",", epoch 297 , total_reward -411.16883752541634, loss_actor = [-100.0], loss_critic1 = 0.04197407672343685, loss_critic2 = 0.023008969060050035, std = 7.511433677020411e-09\n",", epoch 298 , total_reward -310.581182600288, loss_actor = 7.461857440284205, loss_critic1 = 0.05815242939216811, loss_critic2 = 0.06757490440336293, std = 6.796456283872769e-09\n",", epoch 299 , total_reward -433.39670385230295, loss_actor = [-100.0], loss_critic1 = 0.09134044520337753, loss_critic2 = 0.09564493742600924, std = 6.149534164151304e-09\n",", epoch 300 , total_reward -276.25797548290626, loss_actor = [-100.0], loss_critic1 = 0.031539385622299305, loss_critic2 = 0.028634158915956685, std = 5.564189462352468e-09\n",", epoch 301 , total_reward -277.1112368142653, loss_actor = 6.573684694862852, loss_critic1 = 0.04641237689949364, loss_critic2 = 0.04622326105037452, std = 5.034560919010208e-09\n",", epoch 302 , total_reward -143.68921737311248, loss_actor = [-100.0], loss_critic1 = 0.04686085430348459, loss_critic2 = 0.014614193525806137, std = 4.555345179872539e-09\n",", epoch 303 , total_reward -138.2457336336574, loss_actor = [-100.0], loss_critic1 = 0.06221712530704504, loss_critic2 = 0.054022976494074705, std = 4.121743691576511e-09\n",", epoch 304 , total_reward -138.6861432407147, loss_actor = 9.437567855398115, loss_critic1 = 0.04273430663275989, loss_critic2 = 0.022281357610650688, std = 3.72941465206949e-09\n",", epoch 305 , total_reward -136.3947471394223, loss_actor = [-100.0], loss_critic1 = 0.07741918868118026, loss_critic2 = 0.046744956370072255, std = 3.3744295346396892e-09\n",", epoch 306 , total_reward -138.6012864525381, loss_actor = [-100.0], loss_critic1 = 0.03134123186195928, loss_critic2 = 0.008088718775458087, std = 3.053233750216001e-09\n",", epoch 307 , total_reward -133.94429296172387, loss_actor = 12.990045228085211, loss_critic1 = 0.0349618931697131, loss_critic2 = 0.04729609248909361, std = 2.7626110540350815e-09\n",", epoch 308 , total_reward -669.4063809445056, loss_actor = [-100.0], loss_critic1 = 0.04096327080007515, loss_critic2 = 0.06112459641017989, std = 2.4996513402673157e-09\n",", epoch 309 , total_reward -138.401509654456, loss_actor = [-100.0], loss_critic1 = 0.09967460163286376, loss_critic2 = 0.10807697974315107, std = 2.26172150211806e-09\n",", epoch 310 , total_reward -139.0929857944554, loss_actor = 14.330596269073528, loss_critic1 = 0.06691881150003265, loss_critic2 = 0.09224934303663453, std = 2.0464390656162993e-09\n",", epoch 311 , total_reward -141.28898375509576, loss_actor = [-100.0], loss_critic1 = 0.03960698799374961, loss_critic2 = 0.025097322680221072, std = 1.851648333076644e-09\n",", epoch 312 , total_reward -9.256442421582555, loss_actor = [-100.0], loss_critic1 = 0.06280413636200491, loss_critic2 = 0.02927847608398182, std = 1.6753987973509318e-09\n",", epoch 313 , total_reward -141.9150993667085, loss_actor = 9.860612427433983, loss_critic1 = 0.04744775362584548, loss_critic2 = 0.020780291132270652, std = 1.5159256107238176e-09\n",", epoch 314 , total_reward -135.86206270428497, loss_actor = [-100.0], loss_critic1 = 0.04412501012893441, loss_critic2 = 0.030320102668269042, std = 1.3716319128806385e-09\n",", epoch 315 , total_reward -136.86441415995796, loss_actor = [-100.0], loss_critic1 = 0.06631230837709365, loss_critic2 = 0.07262451198665154, std = 1.2410728409913792e-09\n",", epoch 316 , total_reward -339.4861353688836, loss_actor = 7.2517703546917645, loss_critic1 = 0.08933952658657238, loss_critic2 = 0.05673114400543882, std = 1.1229410617981515e-09\n",", epoch 317 , total_reward -140.32889659598635, loss_actor = [-100.0], loss_critic1 = 0.049415770250308494, loss_critic2 = 0.039288399230642104, std = 1.0160536808339673e-09\n",", epoch 318 , total_reward -137.1525832814811, loss_actor = [-100.0], loss_critic1 = 0.02735073439043049, loss_critic2 = 0.03323679202726897, std = 9.19340397690276e-10\n",", epoch 319 , total_reward -138.25168320379586, loss_actor = 12.181903695602601, loss_critic1 = 0.04098210988532226, loss_critic2 = 0.038323661039322374, std = 8.318327887278494e-10\n",", epoch 320 , total_reward -142.43139530065966, loss_actor = [-100.0], loss_critic1 = 0.012229028213548635, loss_critic2 = 0.013825238109926544, std = 7.526546099150819e-10\n",", epoch 321 , total_reward -141.10630030155136, loss_actor = [-100.0], loss_critic1 = 0.018630956515418663, loss_critic2 = 0.025431377059856836, std = 6.810130226926671e-10\n",", epoch 322 , total_reward -266.68578231812984, loss_actor = 13.581763809062576, loss_critic1 = 0.07675625899109832, loss_critic2 = 0.032444642395936, std = 6.161906550061913e-10\n",", epoch 323 , total_reward -139.79019869260335, loss_actor = [-100.0], loss_critic1 = 0.032303779772394285, loss_critic2 = 0.01541264272369764, std = 5.575384180109995e-10\n",", epoch 324 , total_reward -389.7158361876716, loss_actor = [-100.0], loss_critic1 = 0.05987694062758198, loss_critic2 = 0.0713223646272316, std = 5.044690065205311e-10\n",", epoch 325 , total_reward -134.051165282039, loss_actor = 8.096384878806838, loss_critic1 = 0.12933734193218807, loss_critic2 = 0.181998462613074, std = 4.56451018115832e-10\n",", epoch 326 , total_reward -256.36194303303233, loss_actor = [-100.0], loss_critic1 = 0.06842782849493068, loss_critic2 = 0.01959868259417869, std = 4.1300363202887956e-10\n"],"name":"stdout"},{"output_type":"error","ename":"KeyboardInterrupt","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m<ipython-input-67-a453c20a6bcb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0magent_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0magent_actor_critic\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;32m----> 2\u001b[0;31m \u001b[0magent_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_execute\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[0;32m<ipython-input-66-c348e158731a>\u001b[0m in \u001b[0;36mstart_execute\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     43\u001b[0m           \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstd_target\u001b[0m \u001b[0;34m*=\u001b[0m \u001b[0;36m0.9995\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     44\u001b[0m           \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlearn_cnt\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 45\u001b[0;31m           \u001b[0mloss_actor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss_critic1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss_critic2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlearn\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     46\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mdone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m           \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m<ipython-input-66-c348e158731a>\u001b[0m in \u001b[0;36mlearn\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     82\u001b[0m     \u001b[0mloss_critic2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\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     83\u001b[0m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcritic_network1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\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;32m---> 84\u001b[0;31m     \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcritic_network2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\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     85\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     86\u001b[0m     \u001b[0mloss_actor\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTensor\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m100\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;32m/usr/local/lib/python3.7/dist-packages/torch/optim/optimizer.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     87\u001b[0m                 \u001b[0mprofile_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"Optimizer.step#{}.step\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     88\u001b[0m                 \u001b[0;32mwith\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprofiler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrecord_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprofile_name\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;32m---> 89\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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     90\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.7/dist-packages/torch/autograd/grad_mode.py\u001b[0m in \u001b[0;36mdecorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     25\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mdecorate_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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     26\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m(\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;32m---> 27\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\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     28\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mcast\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mF\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdecorate_context\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.7/dist-packages/torch/optim/adam.py\u001b[0m in \u001b[0;36mstep\u001b[0;34m(self, closure)\u001b[0m\n\u001b[1;32m    117\u001b[0m                    \u001b[0mgroup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'lr'\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    118\u001b[0m                    \u001b[0mgroup\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'weight_decay'\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;32m--> 119\u001b[0;31m                    group['eps'])\n\u001b[0m\u001b[1;32m    120\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.7/dist-packages/torch/optim/_functional.py\u001b[0m in \u001b[0;36madam\u001b[0;34m(params, grads, exp_avgs, exp_avg_sqs, max_exp_avg_sqs, state_steps, amsgrad, beta1, beta2, lr, weight_decay, eps)\u001b[0m\n\u001b[1;32m     90\u001b[0m             \u001b[0mdenom\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mmax_exp_avg_sqs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbias_correction2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meps\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     91\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 92\u001b[0;31m             \u001b[0mdenom\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mexp_avg_sq\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbias_correction2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meps\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     93\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     94\u001b[0m         \u001b[0mstep_size\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlr\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mbias_correction1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "]}]},{"cell_type":"markdown","metadata":{"id":"RQ-sP4zxyFPc"},"source":["# 执行交互"]},{"cell_type":"code","metadata":{"id":"DQzhsAEFslfu"},"source":[""],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"Bynw5suyxqNx"},"source":[""],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"FF9iIfWIbSwd"},"source":["%debug"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"q8LRYxa6bSzM"},"source":[""],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"u0M-kBZNbS1m"},"source":[""],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"ePgKNrUfbS4Q"},"source":[""],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"d7K2Wmz0cbs1"},"source":["# 测试工具"]},{"cell_type":"code","metadata":{"id":"S8ZvTK8UbS63"},"source":["! git clone https://github.com/vy007vikas/PyTorch-ActorCriticRL.git"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"2H-qvLTxDG4G"},"source":["! python2 ./PyTorch-ActorCriticRL/main.py"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"iiJSaB5UDG1t"},"source":["! pip2 install box2d"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"s-Vi4Y84DGzA"},"source":[""],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"4v7gpUK5Sqof"},"source":["import tensorflow.compat.v1 as tf\n","tf.disable_v2_behavior\n","tf.compat.v1.disable_eager_execution()\n","tf.reset_default_graph()\n","\n","import numpy as np\n","import gym\n","import time\n","import matplotlib.pyplot as plt\n","\n","MAX_EPISODES = 200\n","LR_A = 0.001    # learning rate for actor\n","LR_C = 0.001    # learning rate for critic\n","GAMMA = 0.9     # reward discount\n","REPLACEMENT = [\n","    dict(name='soft', tau=0.01),\n","    dict(name='hard', rep_iter_a=600, rep_iter_c=500)\n","][0]            # you can try different target replacement strategies\n","\n","MEMORY_CAPACITY = 20000\n","BATCH_SIZE = 32\n","\n","ENV_NAME = 'Pendulum-v0'\n","\n","class Actor(object):\n","    def __init__(self, sess, action_dim, action_bound, learning_rate, replacement):\n","        self.sess = sess\n","        self.a_dim = action_dim\n","        self.action_bound = action_bound\n","        self.lr = learning_rate\n","        self.replacement = replacement\n","        self.t_replace_counter = 0\n","\n","        with tf.variable_scope('Actor'):\n","            self.a = self._build_net(S, scope='eval_net', trainable=True)\n","            self.a_ = self._build_net(S_, scope='target_net', trainable=False)\n","\n","        self.e_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Actor/eval_net')\n","        self.t_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Actor/target_net')\n","\n","        if self.replacement['name'] == 'hard':\n","            self.t_replace_counter = 0\n","            self.hard_replace = [tf.assign(t, e) for t, e in zip(self.t_params, self.e_params)]\n","        else:\n","            self.soft_replace = [tf.assign(t, (1 - self.replacement['tau']) * t + self.replacement['tau'] * e)\n","                                 for t, e in zip(self.t_params, self.e_params)]\n","\n","    def _build_net(self, s, scope, trainable):\n","        with tf.variable_scope(scope):\n","            init_w = tf.random_normal_initializer(0., 0.3)\n","            init_b = tf.constant_initializer(0.1)\n","            net = tf.layers.dense(s, 30, activation=tf.nn.relu,\n","                                  kernel_initializer=init_w, bias_initializer=init_b, name='l1',\n","                                  trainable=trainable)\n","            with tf.variable_scope('a'):\n","                actions = tf.layers.dense(net, self.a_dim, activation=tf.nn.tanh, kernel_initializer=init_w,\n","                                          bias_initializer=init_b, name='a', trainable=trainable)\n","                scaled_a = tf.multiply(actions, self.action_bound, name='scaled_a')  # Scale output to -action_bound to action_bound\n","        return scaled_a\n","\n","    def learn(self, s):   # batch update\n","        self.sess.run(self.train_op, feed_dict={S: s})\n","        if self.replacement['name'] == 'soft':\n","            self.sess.run(self.soft_replace)\n","        else:\n","            if self.t_replace_counter % self.replacement['rep_iter_a'] == 0:\n","                self.sess.run(self.hard_replace)\n","            self.t_replace_counter += 1\n","\n","    def choose_action(self, s):\n","        s = s[np.newaxis, :]    # single state\n","        return self.sess.run(self.a, feed_dict={S: s})[0]  # single action\n","\n","    def add_grad_to_graph(self, a_grads):\n","        with tf.variable_scope('policy_grads'):\n","            # ys = policy;\n","            # xs = policy's parameters;\n","            # a_grads = the gradients of the policy to get more Q\n","            # tf.gradients will calculate dys/dxs with a initial gradients for ys, so this is dq/da * da/dparams\n","            self.policy_grads = tf.gradients(ys=self.a, xs=self.e_params, grad_ys=a_grads)\n","\n","        with tf.variable_scope('A_train'):\n","            opt = tf.train.AdamOptimizer(-self.lr)  # (- learning rate) for ascent policy\n","            self.train_op = opt.apply_gradients(zip(self.policy_grads, self.e_params))\n","\n","class Critic(object):\n","    def __init__(self, sess, state_dim, action_dim, learning_rate, gamma, replacement, a, a_):\n","        self.sess = sess\n","        self.s_dim = state_dim\n","        self.a_dim = action_dim\n","        self.lr = learning_rate\n","        self.gamma = gamma\n","        self.replacement = replacement\n","\n","        with tf.variable_scope('Critic'):\n","            # Input (s, a), output q\n","            self.a = tf.stop_gradient(a)    # stop critic update flows to actor\n","            self.q = self._build_net(S, self.a, 'eval_net', trainable=True)\n","            self.q_ = self._build_net(S_, a_, 'target_net', trainable=False)    # target_q is based on a_ from Actor's target_net\n","\n","            self.e_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic/eval_net')\n","            self.t_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic/target_net')\n","\n","        with tf.variable_scope('target_q'):\n","            self.target_q = R + self.gamma * self.q_\n","        with tf.variable_scope('TD_error'):\n","            self.loss = tf.reduce_mean(tf.squared_difference(self.target_q, self.q))\n","        with tf.variable_scope('C_train'):\n","            self.train_op = tf.train.AdamOptimizer(self.lr).minimize(self.loss)\n","        with tf.variable_scope('a_grad'):\n","            self.a_grads = tf.gradients(self.q, self.a)[0]   # tensor of gradients of each sample (None, a_dim)\n","        if self.replacement['name'] == 'hard':\n","            self.t_replace_counter = 0\n","            self.hard_replacement = [tf.assign(t, e) for t, e in zip(self.t_params, self.e_params)]\n","        else:\n","            self.soft_replacement = [tf.assign(t, (1 - self.replacement['tau']) * t + self.replacement['tau'] * e)\n","                                     for t, e in zip(self.t_params, self.e_params)]\n","\n","    def _build_net(self, s, a, scope, trainable):\n","        with tf.variable_scope(scope):\n","            init_w = tf.random_normal_initializer(0., 0.1)\n","            init_b = tf.constant_initializer(0.1)\n","\n","            with tf.variable_scope('l1'):\n","                n_l1 = 30\n","                w1_s = tf.get_variable('w1_s', [self.s_dim, n_l1], initializer=init_w, trainable=trainable)\n","                w1_a = tf.get_variable('w1_a', [self.a_dim, n_l1], initializer=init_w, trainable=trainable)\n","                b1 = tf.get_variable('b1', [1, n_l1], initializer=init_b, trainable=trainable)\n","                net = tf.nn.relu(tf.matmul(s, w1_s) + tf.matmul(a, w1_a) + b1)\n","\n","            with tf.variable_scope('q'):\n","                q = tf.layers.dense(net, 1, kernel_initializer=init_w, bias_initializer=init_b, trainable=trainable)   # Q(s,a)\n","        return q\n","\n","    def learn(self, s, a, r, s_):\n","        self.sess.run(self.train_op, feed_dict={S: s, self.a: a, R: r, S_: s_})\n","        if self.replacement['name'] == 'soft':\n","            self.sess.run(self.soft_replacement)\n","        else:\n","            if self.t_replace_counter % self.replacement['rep_iter_c'] == 0:\n","                self.sess.run(self.hard_replacement)\n","            self.t_replace_counter += 1\n","\n","class Memory(object):\n","    def __init__(self, capacity, dims):\n","        self.capacity = capacity\n","        self.data = np.zeros((capacity, dims))\n","        self.pointer = 0\n","\n","    def store_transition(self, s, a, r, s_):\n","        transition = np.hstack((s, a, [r], s_))\n","        index = self.pointer % self.capacity  # replace the old memory with new memory\n","        self.data[index, :] = transition\n","        self.pointer += 1\n","\n","    def sample(self, n):\n","        assert self.pointer >= self.capacity, 'Memory has not been fulfilled'\n","        indices = np.random.choice(self.capacity, size=n)\n","        return self.data[indices, :]\n","\n","\n","env = gym.make(ENV_NAME)\n","\n","state_dim = env.observation_space.shape[0]\n","action_dim = env.action_space.shape[0]\n","action_bound = env.action_space.high\n","\n","# all placeholder for tf\n","with tf.name_scope('S'):\n","    S = tf.placeholder(tf.float32, shape=[None, state_dim], name='s')\n","with tf.name_scope('R'):\n","    R = tf.placeholder(tf.float32, [None, 1], name='r')\n","with tf.name_scope('S_'):\n","    S_ = tf.placeholder(tf.float32, shape=[None, state_dim], name='s_')\n","\n","\n","sess = tf.Session()\n","\n","# Create actor and critic.\n","# They are actually connected to each other, details can be seen in tensorboard or in this picture:\n","actor = Actor(sess, action_dim, action_bound, LR_A, REPLACEMENT)\n","critic = Critic(sess, state_dim, action_dim, LR_C, GAMMA, REPLACEMENT, actor.a, actor.a_)\n","actor.add_grad_to_graph(critic.a_grads)\n","\n","sess.run(tf.global_variables_initializer())\n","\n","M = Memory(MEMORY_CAPACITY, dims=2 * state_dim + action_dim + 1)\n","\n","var = 3  # control exploration\n","\n","reward_array = []\n","for i in range(MAX_EPISODES):\n","    s = env.reset()\n","    ep_reward = 0\n","\n","    while True:\n","        a = actor.choose_action(s)\n","        a = np.clip(np.random.normal(a, var), -2, 2)    # add randomness to action selection for exploration\n","        s_, r, done, info = env.step(a)\n","\n","        M.store_transition(s, a, r, s_)\n","\n","        if M.pointer > MEMORY_CAPACITY:\n","            var *= .9995    # decay the action randomness\n","            b_M = M.sample(BATCH_SIZE)\n","            b_s = b_M[:, :state_dim]\n","            b_a = b_M[:, state_dim: state_dim + action_dim]\n","            b_r = b_M[:, -state_dim - 1: -state_dim]\n","            b_s_ = b_M[:, -state_dim:]\n","\n","            critic.learn(b_s, b_a, b_r, b_s_)\n","            actor.learn(b_s)\n","\n","        s = s_\n","        ep_reward += r\n","\n","        if done:\n","            print('Episode:', i, ' Reward: %i' % int(ep_reward), 'Explore: %.2f' % var, )\n","            reward_array.append(ep_reward)\n","            s = env.reset()\n","            break\n","plot_array(reward_array,'episode','total_reward')\n","print('Running time: ', time.time()-t1)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"tPb27RroSql3"},"source":[""],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"33RqbWC7vuL0"},"source":["# 测试工具2"]},{"cell_type":"code","metadata":{"id":"xzHQE0s8SqjT"},"source":["import tensorflow.compat.v1 as tf\n","tf.disable_v2_behavior\n","tf.compat.v1.disable_eager_execution()\n","tf.reset_default_graph()\n","import numpy as np\n","import gym\n","import time\n","\n","MAX_EPISODES = 2000\n","MAX_EP_STEPS = 200\n","LR_A = 0.001    # learning rate for actor\n","LR_C = 0.002    # learning rate for critic\n","GAMMA = 0.9     # reward discount\n","TAU = 0.01      # soft replacement\n","MEMORY_CAPACITY = 10000\n","BATCH_SIZE = 32\n","\n","ENV_NAME = 'Pendulum-v0'\n","\n","class DDPG(object):\n","    def __init__(self, a_dim, s_dim, a_bound,):\n","        self.memory = np.zeros((MEMORY_CAPACITY, s_dim * 2 + a_dim + 1), dtype=np.float32)\n","        self.pointer = 0\n","        self.sess = tf.Session()\n","\n","        self.a_dim, self.s_dim, self.a_bound = a_dim, s_dim, a_bound,\n","        self.S = tf.placeholder(tf.float32, [None, s_dim], 's')\n","        self.S_ = tf.placeholder(tf.float32, [None, s_dim], 's_')\n","        self.R = tf.placeholder(tf.float32, [None, 1], 'r')\n","\n","        with tf.variable_scope('Actor'):\n","            self.a = self._build_a(self.S, scope='eval', trainable=True)\n","            a_ = self._build_a(self.S_, scope='target', trainable=False)\n","        with tf.variable_scope('Critic'):\n","            # assign self.a = a in memory when calculating q for td_error,\n","            # otherwise the self.a is from Actor when updating Actor\n","            q = self._build_c(self.S, self.a, scope='eval', trainable=True)\n","            q_ = self._build_c(self.S_, a_, scope='target', trainable=False)\n","\n","        # networks parameters\n","        self.ae_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Actor/eval')\n","        self.at_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Actor/target')\n","        self.ce_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic/eval')\n","        self.ct_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic/target')\n","\n","        # target net replacement\n","        self.soft_replace = [tf.assign(t, (1 - TAU) * t + TAU * e)\n","                             for t, e in zip(self.at_params + self.ct_params, self.ae_params + self.ce_params)]\n","\n","        q_target = self.R + GAMMA * q_\n","        # in the feed_dic for the td_error, the self.a should change to actions in memory\n","        td_error = tf.losses.mean_squared_error(labels=q_target, predictions=q)\n","        self.ctrain = tf.train.AdamOptimizer(LR_C).minimize(td_error, var_list=self.ce_params)\n","\n","        a_loss = - tf.reduce_mean(q)    # maximize the q\n","        self.atrain = tf.train.AdamOptimizer(LR_A).minimize(a_loss, var_list=self.ae_params)\n","\n","        self.sess.run(tf.global_variables_initializer())\n","\n","    def choose_action(self, s):\n","        return self.sess.run(self.a, {self.S: s[np.newaxis, :]})[0]\n","\n","    def learn(self):\n","        # soft target replacement\n","        self.sess.run(self.soft_replace)\n","\n","        indices = np.random.choice(MEMORY_CAPACITY, size=BATCH_SIZE)\n","        bt = self.memory[indices, :]\n","        bs = bt[:, :self.s_dim]\n","        ba = bt[:, self.s_dim: self.s_dim + self.a_dim]\n","        br = bt[:, -self.s_dim - 1: -self.s_dim]\n","        bs_ = bt[:, -self.s_dim:]\n","\n","        self.sess.run(self.atrain, {self.S: bs})\n","        self.sess.run(self.ctrain, {self.S: bs, self.a: ba, self.R: br, self.S_: bs_})\n","\n","    def store_transition(self, s, a, r, s_):\n","        transition = np.hstack((s, a, [r], s_))\n","        index = self.pointer % MEMORY_CAPACITY  # replace the old memory with new memory\n","        self.memory[index, :] = transition\n","        self.pointer += 1\n","\n","    def _build_a(self, s, scope, trainable):\n","        with tf.variable_scope(scope):\n","            net = tf.layers.dense(s, 30, activation=tf.nn.relu, name='l1', trainable=trainable)\n","            a = tf.layers.dense(net, self.a_dim, activation=tf.nn.tanh, name='a', trainable=trainable)\n","            return tf.multiply(a, self.a_bound, name='scaled_a')\n","\n","    def _build_c(self, s, a, scope, trainable):\n","        with tf.variable_scope(scope):\n","            n_l1 = 30\n","            w1_s = tf.get_variable('w1_s', [self.s_dim, n_l1], trainable=trainable)\n","            w1_a = tf.get_variable('w1_a', [self.a_dim, n_l1], trainable=trainable)\n","            b1 = tf.get_variable('b1', [1, n_l1], trainable=trainable)\n","            net = tf.nn.relu(tf.matmul(s, w1_s) + tf.matmul(a, w1_a) + b1)\n","            return tf.layers.dense(net, 1, trainable=trainable)  # Q(s,a)\n","\n","###############################  training  ####################################\n","\n","env = gym.make(ENV_NAME)\n","env = env.unwrapped\n","env.seed(1)\n","\n","s_dim = env.observation_space.shape[0]\n","a_dim = env.action_space.shape[0]\n","a_bound = env.action_space.high\n","\n","ddpg = DDPG(a_dim, s_dim, a_bound)\n","\n","var = 3  # control exploration\n","t1 = time.time()\n","for episode in range(MAX_EPISODES):\n","    s = env.reset()\n","    ep_reward = 0\n","    for j in range(MAX_EP_STEPS):\n","        if RENDER:\n","            env.render()\n","\n","        # Add exploration noise\n","        a = ddpg.choose_action(s)\n","        a = np.clip(np.random.normal(a, var), -2, 2)    # add randomness to action selection for exploration\n","        s_, r, done, info = env.step(a)\n","\n","        ddpg.store_transition(s, a, r / 10, s_)\n","\n","        if ddpg.pointer > MEMORY_CAPACITY:\n","            var *= .9995    # decay the action randomness\n","            ddpg.learn()\n","\n","        s = s_\n","        ep_reward += r\n","        if j == MAX_EP_STEPS-1:\n","            print('Episode:', episode, ' Reward: %i' % int(ep_reward), 'Explore: %.2f' % var, )\n","            # if ep_reward > -300:RENDER = True\n","            break\n","    if episode % 100 == 0:\n","      total_reward = 0\n","      for i in range(10):\n","        state = env.reset()\n","        for j in range(MAX_EP_STEPS):\n","\n","          action = ddpg.choose_action(state) # direct action for test\n","          state,reward,done,_ = env.step(action)\n","          total_reward += reward\n","          if done:\n","            break\n","      ave_reward = total_reward/300\n","      print ('episode: ',episode,'Evaluation Average Reward:',ave_reward)\n","print('Running time: ', time.time() - t1)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"pPxXeEdCSqgr"},"source":[""],"execution_count":null,"outputs":[]}]}