Coding/Practice-6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DDPG\n",
    "\n",
    "Задаем структуру аппроксимаций $\\pi^\\eta(s)$, $Q^\\theta(s,a)$ и начальные вектора параметров $\\eta$, $\\theta$.\n",
    "\n",
    "Для каждого эпизода делаем:\n",
    "\n",
    "   Пока эпизод не закончен делаем:\n",
    "\n",
    "- Находясь в состоянии $S_t$ совершаем действие\n",
    "\n",
    "    $$\n",
    "    A_t = \\pi^\\eta(S_t) + Noise,\n",
    "    $$\n",
    "\n",
    "    получаем награду $R_t$  переходим в состояние $S_{t+1}$. Сохраняем \n",
    "    $(S_t,A_t,R_t,S_{t+1}) \\Rightarrow Memory$\n",
    "\n",
    "\n",
    "- Берем $\\{(s_i,a_i,r_i,s'_i)\\}_{i=1}^{n} \\leftarrow Memory$, определяем значения\n",
    "\n",
    "    $$\n",
    "    y_i = r_i + \\gamma Q^\\theta(s'_i,\\pi^\\eta(s'_i))\n",
    "    $$\n",
    "    функции потерь\n",
    "\n",
    "    $$\n",
    "    Loss_1(\\theta) = \\frac{1}{n}\\sum\\limits_{i=1}^n \\big(y_i - Q^\\theta(s_i,a_i)\\big)^2,\\quad Loss_2(\\eta) = \\frac{1}{n}\\sum\\limits_{i=1}^n Q^\\theta(s_i,\\pi^\\eta(s_i))\n",
    "    $$\n",
    "\n",
    "    и обновляем вектор параметров\n",
    "\n",
    "    $$\n",
    "    \\theta \\leftarrow \\theta - \\alpha \\nabla_\\theta Loss_1(\\theta),\\quad \\eta \\leftarrow \\eta + \\beta \\nabla_\\eta Loss_2(\\eta),\\quad \\alpha,\\beta > 0\n",
    "    $$\n",
    "\n",
    "- Уменьшаем $Noise$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-10T13:19:40.443616Z",
     "start_time": "2020-12-10T13:19:40.430613Z"
    }
   },
   "outputs": [],
   "source": [
    "#Ornstein–Uhlenbeck process (Процесс Орнштейна – Уленбека)\n",
    "\n",
    "class OUNoise:\n",
    "    def __init__(self, action_dimension, mu=0, theta=0.15, sigma=0.3):\n",
    "        self.action_dimension = action_dimension\n",
    "        self.mu = mu\n",
    "        self.theta = theta\n",
    "        self.sigma = sigma\n",
    "        self.state = np.ones(self.action_dimension) * self.mu\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.state = np.ones(self.action_dimension) * self.mu\n",
    "\n",
    "    def sample(self):\n",
    "        x = self.state\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.random.randn(len(x))\n",
    "        self.state = x + dx\n",
    "        return self.state"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-10T13:32:18.792167Z",
     "start_time": "2020-12-10T13:32:18.748995Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import random\n",
    "from collections import deque\n",
    "from copy import deepcopy\n",
    "\n",
    "\n",
    "class TwoLayersNeywork(nn.Module):\n",
    "    def __init__(self, input_dim, layer_1_dim, layer_2_dim, output_dim, is_tanh):\n",
    "        super().__init__()\n",
    "        self.linear_1 = nn.Linear(input_dim, layer_1_dim)\n",
    "        self.linear_2 = nn.Linear(layer_1_dim, layer_2_dim)\n",
    "        self.linear_3 = nn.Linear(layer_2_dim, output_dim)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.is_tanh = is_tanh\n",
    "        self.tanh = nn.Tanh()\n",
    "        \n",
    "    def forward(self, input):\n",
    "        hidden = self.linear_1(input)\n",
    "        hidden = self.relu(hidden)\n",
    "        hidden = self.linear_2(hidden)\n",
    "        hidden = self.relu(hidden)\n",
    "        output = self.linear_3(hidden)\n",
    "        if self.is_tanh:\n",
    "            output = self.tanh(output)\n",
    "        return output\n",
    "    \n",
    "\n",
    "class DDPG():\n",
    "    def __init__(self, state_dim, action_dim, action_max, gamma=0.99, tau=1e-3,\n",
    "                 batch_size=64, q_model_lr=1e-3, pi_model_lr=1e-4, noise_decrease=0.01):\n",
    "        self.state_dim = state_dim\n",
    "        self.action_dim = action_dim\n",
    "        self.action_max = action_max\n",
    "        self.pi_model = TwoLayersNeywork(state_dim, 400, 300, action_dim, is_tanh=True)\n",
    "        self.pi_target_model = deepcopy(self.pi_model)\n",
    "        self.q_model = TwoLayersNeywork(state_dim + action_dim, 400, 300, 1, is_tanh=False)\n",
    "        self.q_target_model = deepcopy(self.q_model)\n",
    "        self.noise = OUNoise(self.action_dim)\n",
    "        self.noise_threshold = 1\n",
    "        self.noise_decrease = noise_decrease\n",
    "        self.noise_min = 0.01\n",
    "        self.memory = deque(maxlen=10000)\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.q_optimazer = torch.optim.Adam(self.q_model.parameters(), lr=q_model_lr)\n",
    "        self.pi_optimazer = torch.optim.Adam(self.pi_model.parameters(), lr=pi_model_lr)\n",
    "    \n",
    "    def get_action(self, state):\n",
    "        state = torch.FloatTensor(state)\n",
    "        _action = self.pi_model(state).detach().data.numpy() + self.noise_threshold * self.noise.sample()\n",
    "        return self.action_max * _action\n",
    "    \n",
    "    def update_target_model(self, target_model, model, optimazer, loss):\n",
    "        optimazer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimazer.step()\n",
    "        for target_param, param in zip(target_model.parameters(), model.parameters()):\n",
    "            target_param.data.copy_((1 - self.tau) * target_param.data + self.tau * param.data)        \n",
    "    \n",
    "    def fit(self, state, action, reward, done, next_state):\n",
    "        self.memory.append([state, action, reward, done, next_state])\n",
    "        \n",
    "        if len(self.memory) >= self.batch_size:\n",
    "            batch = random.sample(self.memory, self.batch_size)\n",
    "            states, actions, rewards, dones, next_states = map(torch.FloatTensor, zip(*batch))\n",
    "            rewards = rewards.reshape(self.batch_size, 1)\n",
    "            dones = dones.reshape(self.batch_size, 1)\n",
    "            \n",
    "            pred_next_actions = self.action_max * self.pi_target_model(next_states)\n",
    "            next_states_and_pred_next_actions = torch.cat((next_states, pred_next_actions), dim=1)\n",
    "            targets = rewards + self.gamma * (1 - dones) * self.q_target_model(next_states_and_pred_next_actions)\n",
    "            \n",
    "            states_and_actions = torch.cat((states, actions), dim=1)\n",
    "            temp = (self.q_model(states_and_actions) - targets.detach())\n",
    "            q_loss = torch.mean((targets.detach() - self.q_model(states_and_actions)) ** 2)\n",
    "            self.update_target_model(self.q_target_model, self.q_model, self.q_optimazer, q_loss)\n",
    "            \n",
    "            pred_actions = self.action_max * self.pi_model(states)\n",
    "            states_and_pred_actions = torch.cat((states, pred_actions), dim=1)\n",
    "            pi_loss = - torch.mean(self.q_model(states_and_pred_actions))\n",
    "            self.update_target_model(self.pi_target_model, self.pi_model, self.pi_optimazer, pi_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-12-10T13:47:46.108496Z",
     "start_time": "2020-12-10T13:32:18.797167Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.display import clear_output\n",
    "\n",
    "\n",
    "env = gym.make('Pendulum-v0')\n",
    "agent = DDPG(state_dim=3, action_dim=1, action_max=2)\n",
    "\n",
    "episode_n = 200\n",
    "session_len = 200\n",
    "total_rewards = []\n",
    "\n",
    "for episode in range(episode_n):\n",
    "    state = env.reset()\n",
    "    total_reward = 0\n",
    "    for _ in range(session_len):\n",
    "        action = agent.get_action(state)\n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        agent.fit(state, action, reward, done, next_state)\n",
    "        state = next_state\n",
    "        total_reward += reward\n",
    "    total_rewards.append(total_reward)\n",
    "    plt.plot(total_rewards)\n",
    "    clear_output(True)    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}