week09_policy_II/seminar_TRPO_tensorflow.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# launch XVFB if you run on a server\n",
    "import os\n",
    "if type(os.environ.get(\"DISPLAY\")) is not str or len(os.environ.get(\"DISPLAY\")) == 0:\n",
    "    !bash ../xvfb start\n",
    "    os.environ['DISPLAY'] = ':1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's make a TRPO!\n",
    "\n",
    "In this notebook we will write the code of the one Trust Region Policy Optimization.\n",
    "As usually, it contains a few different parts which we are going to reproduce.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "\n",
    "env = gym.make(\"Acrobot-v1\")\n",
    "env.reset()\n",
    "observation_shape = env.observation_space.shape\n",
    "n_actions = env.action_space.n\n",
    "print(\"Observation Space\", env.observation_space)\n",
    "print(\"Action Space\", env.action_space)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "plt.imshow(env.render('rgb_array'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1: Defining a network\n",
    "\n",
    "With all it's complexity, at it's core TRPO is yet another policy gradient method. \n",
    "\n",
    "This essentially means we're actually training a stochastic policy $ \\pi_\\theta(a|s) $. \n",
    "\n",
    "And yes, it's gonna be a neural network. So let's start by defining one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input tensors\n",
    "observations_ph = tf.placeholder(\n",
    "    shape=(None, observation_shape[0]), dtype=tf.float32)\n",
    "# Actions that we made\n",
    "actions_ph = tf.placeholder(shape=(None,), dtype=tf.int32)\n",
    "# \"G = r + gamma*r' + gamma^2*r'' + ...\"\n",
    "cummulative_returns_ph = tf.placeholder(shape=(None,), dtype=tf.float32)\n",
    "# Action probabilities from previous iteration\n",
    "old_probs_ph = tf.placeholder(shape=(None, n_actions), dtype=tf.float32)\n",
    "\n",
    "all_inputs = [observations_ph, actions_ph,\n",
    "              cummulative_returns_ph, old_probs_ph]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def denselayer(name, x, out_dim, nonlinearity=None):\n",
    "    with tf.variable_scope(name):\n",
    "        if nonlinearity is None:\n",
    "            nonlinearity = tf.identity\n",
    "\n",
    "        x_shape = x.get_shape().as_list()\n",
    "\n",
    "        w = tf.get_variable('w', shape=[x_shape[1], out_dim])\n",
    "        b = tf.get_variable(\n",
    "            'b', shape=[out_dim], initializer=tf.constant_initializer(0))\n",
    "        o = nonlinearity(tf.matmul(x, w) + b)\n",
    "\n",
    "        return o\n",
    "\n",
    "\n",
    "sess = tf.InteractiveSession()\n",
    "\n",
    "nn = observations_ph\n",
    "\n",
    "<YOUR CODE: your network here>\n",
    "\n",
    "policy_out = <YOUR CODE: layer that predicts action log-probabilities>\n",
    "\n",
    "probs_out = tf.exp(policy_out)\n",
    "\n",
    "weights = tf.trainable_variables()\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: Actions and rollouts\n",
    "\n",
    "In this section, we'll define functions that take actions $ a \\sim \\pi_\\theta(a|s) $ and rollouts $ <s_0,a_0,s_1,a_1,s_2,a_2,...s_n,a_n> $."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compile function\n",
    "\n",
    "\n",
    "def act(obs, sample=True):\n",
    "    \"\"\"\n",
    "    Samples action from policy distribution (sample = True) or takes most likely action (sample = False)\n",
    "    :param: obs - single observation vector\n",
    "    :param sample: if True, samples from \\pi, otherwise takes most likely action\n",
    "    :returns: action (single integer) and probabilities for all actions\n",
    "    \"\"\"\n",
    "\n",
    "    probs = sess.run(probs_out, feed_dict={\n",
    "                     observations_ph: obs.reshape((1, -1))})[0]\n",
    "\n",
    "    if sample:\n",
    "        action = int(np.random.choice(n_actions, p=probs))\n",
    "    else:\n",
    "        action = int(np.argmax(probs))\n",
    "\n",
    "    return action, probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# demo\n",
    "print(\"sampled:\", [act(env.reset()) for _ in range(5)])\n",
    "print(\"greedy:\", [act(env.reset(), sample=False) for _ in range(5)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute cummulative reward just like you did in vanilla REINFORCE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.signal\n",
    "\n",
    "\n",
    "def get_cummulative_returns(r, gamma=1):\n",
    "    \"\"\"\n",
    "    Computes cummulative discounted rewards given immediate rewards\n",
    "    G_i = r_i + gamma*r_{i+1} + gamma^2*r_{i+2} + ...\n",
    "    Also known as R(s,a).\n",
    "    \"\"\"\n",
    "    r = np.array(r)\n",
    "    assert r.ndim >= 1\n",
    "    return scipy.signal.lfilter([1], [1, -gamma], r[::-1], axis=0)[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simple demo on rewards [0,0,1,0,0,1]\n",
    "get_cummulative_returns([0, 0, 1, 0, 0, 1], gamma=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Rollout**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rollout(env, act, max_pathlength=2500, n_timesteps=50000):\n",
    "    \"\"\"\n",
    "    Generate rollouts for training.\n",
    "    :param: env - environment in which we will make actions to generate rollouts.\n",
    "    :param: act - the function that can return policy and action given observation.\n",
    "    :param: max_pathlength - maximum size of one path that we generate.\n",
    "    :param: n_timesteps - total sum of sizes of all pathes we generate.\n",
    "    \"\"\"\n",
    "    paths = []\n",
    "\n",
    "    total_timesteps = 0\n",
    "    while total_timesteps < n_timesteps:\n",
    "        obervations, actions, rewards, action_probs = [], [], [], []\n",
    "        obervation = env.reset()\n",
    "        for _ in range(max_pathlength):\n",
    "            action, policy = act(obervation)\n",
    "            obervations.append(obervation)\n",
    "            actions.append(action)\n",
    "            action_probs.append(policy)\n",
    "            obervation, reward, done, _ = env.step(action)\n",
    "            rewards.append(reward)\n",
    "            total_timesteps += 1\n",
    "            if done or total_timesteps == n_timesteps:\n",
    "                path = {\"observations\": np.array(obervations),\n",
    "                        \"policy\": np.array(action_probs),\n",
    "                        \"actions\": np.array(actions),\n",
    "                        \"rewards\": np.array(rewards),\n",
    "                        \"cumulative_returns\": get_cummulative_returns(rewards),\n",
    "                        }\n",
    "                paths.append(path)\n",
    "                break\n",
    "    return paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "paths = rollout(env, act, max_pathlength=5, n_timesteps=100)\n",
    "print(paths[-1])\n",
    "assert (paths[0]['policy'].shape == (5, n_actions))\n",
    "assert (paths[0]['cumulative_returns'].shape == (5,))\n",
    "assert (paths[0]['rewards'].shape == (5,))\n",
    "assert (paths[0]['observations'].shape == (5,)+observation_shape)\n",
    "assert (paths[0]['actions'].shape == (5,))\n",
    "print('It\\'s ok')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: loss functions\n",
    "\n",
    "Now let's define the loss functions and constraints for actual TRPO training."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The surrogate reward should be\n",
    "$$J_{surr}= {1 \\over N} \\sum\\limits_{i=0}^N \\frac{\\pi_{\\theta}(s_i, a_i)}{\\pi_{\\theta_{old}}(s_i, a_i)}A_{\\theta_{old}(s_i, a_i)}$$\n",
    "\n",
    "For simplicity, let's use cummulative returns instead of advantage for now:\n",
    "$$J'_{surr}= {1 \\over N} \\sum\\limits_{i=0}^N \\frac{\\pi_{\\theta}(s_i, a_i)}{\\pi_{\\theta_{old}}(s_i, a_i)}G_{\\theta_{old}(s_i, a_i)}$$\n",
    "\n",
    "Or alternatively, minimize the surrogate loss:\n",
    "$$ L_{surr} = - J'_{surr} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# select probabilities of chosen actions\n",
    "batch_size = tf.shape(observations_ph)[0]\n",
    "probs_all = tf.reshape(probs_out, [-1])\n",
    "probs_for_actions = tf.gather(probs_all, tf.range(\n",
    "    0, batch_size) * n_actions + actions_ph)\n",
    "old_probs_all = tf.reshape(old_probs_ph, [-1])\n",
    "old_probs_for_actions = tf.gather(\n",
    "    old_probs_all, tf.range(0, batch_size) * n_actions + actions_ph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute surrogate loss: negative importance-sampled policy gradient\n",
    "\n",
    "L_surr = <YOUR CODE: compute surrogate loss, aka _negative_ importance-sampled policy gradient>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute and return surrogate policy gradient\n",
    "def var_shape(x):\n",
    "    return [k.value for k in x.get_shape()]\n",
    "\n",
    "\n",
    "def numel(x):\n",
    "    return np.prod(var_shape(x))\n",
    "\n",
    "\n",
    "def flatgrad(loss, var_list):\n",
    "    grads = tf.gradients(loss, var_list)\n",
    "    return tf.concat([tf.reshape(grad, [numel(v)])\n",
    "                      for (v, grad) in zip(var_list, grads)], 0)\n",
    "\n",
    "\n",
    "flat_grad_surr = flatgrad(L_surr, weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can ascend these gradients as long as our $pi_\\theta(a|s)$ satisfies the constraint\n",
    "$$E_{s,\\pi_{\\Theta_{t}}}\\Big[KL(\\pi(\\Theta_{t}, s) \\:||\\:\\pi(\\Theta_{t+1}, s))\\Big] < \\alpha$$\n",
    "\n",
    "\n",
    "where\n",
    "\n",
    "$$KL(p||q) = E _p log({p \\over q})$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute Kullback-Leibler divergence (see formula above)\n",
    "# Note: you need to sum KL and entropy over all actions, not just the ones agent took\n",
    "old_log_probs = tf.log(old_probs_ph+1e-10)\n",
    "\n",
    "kl = <YOUR CODE: compute Kullback-Leibler as per formula above>\n",
    "\n",
    "# Compute policy entropy\n",
    "entropy = <YOUR CODE: compute policy entropy. Don't forget the sign!>\n",
    "\n",
    "losses = [L_surr, kl, entropy]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Linear search**\n",
    "\n",
    "TRPO in its core involves ascending surrogate policy gradient constrained by KL divergence. \n",
    "\n",
    "In order to enforce this constraint, we're gonna use linesearch. You can find out more about it [here](https://en.wikipedia.org/wiki/Linear_search)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linesearch(f, x, fullstep, max_kl):\n",
    "    \"\"\"\n",
    "    Linesearch finds the best parameters of neural networks in the direction of fullstep contrainted by KL divergence.\n",
    "    :param: f - function that returns loss, kl and arbitrary third component.\n",
    "    :param: x - old parameters of neural network.\n",
    "    :param: fullstep - direction in which we make search.\n",
    "    :param: max_kl - constraint of KL divergence.\n",
    "    :returns:\n",
    "    \"\"\"\n",
    "    max_backtracks = 10\n",
    "    loss, _, _ = f(x)\n",
    "    for stepfrac in .5**np.arange(max_backtracks):\n",
    "        xnew = x + stepfrac * fullstep\n",
    "        new_loss, kl, _ = f(xnew)\n",
    "        actual_improve = new_loss - loss\n",
    "        if kl <= max_kl and actual_improve < 0:\n",
    "            x = xnew\n",
    "            loss = new_loss\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 4: training\n",
    "In this section we construct rest parts of our computational graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def slice_vector(vector, shapes):\n",
    "    \"\"\"\n",
    "    Slices symbolic vector into several symbolic tensors of given shapes.\n",
    "    Auxilary function used to un-flatten gradients, tangents etc.\n",
    "    :param vector: 1-dimensional symbolic vector\n",
    "    :param shapes: list or tuple of shapes (list, tuple or symbolic)\n",
    "    :returns: list of symbolic tensors of given shapes\n",
    "    \"\"\"\n",
    "    assert len(vector.get_shape()) == 1, \"vector must be 1-dimensional\"\n",
    "    start = 0\n",
    "    tensors = []\n",
    "    for shape in shapes:\n",
    "        size = np.prod(shape)\n",
    "        tensor = tf.reshape(vector[start:(start + size)], shape)\n",
    "        tensors.append(tensor)\n",
    "        start += size\n",
    "    return tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# intermediate grad in conjugate_gradient\n",
    "conjugate_grad_intermediate_vector = tf.placeholder(\n",
    "    dtype=tf.float32, shape=(None,))\n",
    "\n",
    "# slice flat_tangent into chunks for each weight\n",
    "weight_shapes = [sess.run(var).shape for var in weights]\n",
    "tangents = slice_vector(conjugate_grad_intermediate_vector, weight_shapes)\n",
    "\n",
    "# KL divergence where first arg is fixed\n",
    "kl_firstfixed = tf.reduce_sum((tf.stop_gradient(probs_out) * (tf.stop_gradient(\n",
    "    tf.log(probs_out)) - tf.log(probs_out)))) / tf.cast(batch_size, tf.float32)\n",
    "\n",
    "# compute fisher information matrix (used for conjugate gradients and to estimate KL)\n",
    "gradients = tf.gradients(kl_firstfixed, weights)\n",
    "gradient_vector_product = [tf.reduce_sum(\n",
    "    g[0] * t) for (g, t) in zip(gradients, tangents)]\n",
    "\n",
    "fisher_vec_prod = flatgrad(gradient_vector_product, weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TRPO helpers\n",
    "\n",
    "Here we define a few helper functions used in the main TRPO loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Conjugate gradients**\n",
    "\n",
    "Since TRPO includes contrainted optimization, we will need to solve Ax=b using conjugate gradients.\n",
    "\n",
    "In general, CG is an algorithm that solves Ax=b where A is positive-defined. A is Hessian matrix so A is positive-defined. You can find out more about them [here](https://en.wikipedia.org/wiki/Conjugate_gradient_method)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.linalg import inv\n",
    "\n",
    "\n",
    "def conjugate_gradient(f_Ax, b, cg_iters=10, residual_tol=1e-10):\n",
    "    \"\"\"\n",
    "    This method solves system of equation Ax=b using iterative method called conjugate gradients\n",
    "    :f_Ax: function that returns Ax\n",
    "    :b: targets for Ax\n",
    "    :cg_iters: how many iterations this method should do\n",
    "    :residual_tol: epsilon for stability\n",
    "    \"\"\"\n",
    "    p = b.copy()\n",
    "    r = b.copy()\n",
    "    x = np.zeros_like(b)\n",
    "    rdotr = r.dot(r)\n",
    "    for i in range(cg_iters):\n",
    "        z = f_Ax(p)\n",
    "        v = rdotr / (p.dot(z) + 1e-8)\n",
    "        x += v * p\n",
    "        r -= v * z\n",
    "        newrdotr = r.dot(r)\n",
    "        mu = newrdotr / (rdotr + 1e-8)\n",
    "        p = r + mu * p\n",
    "        rdotr = newrdotr\n",
    "        if rdotr < residual_tol:\n",
    "            break\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code validates conjugate gradients\n",
    "A = np.random.rand(8, 8)\n",
    "A = np.matmul(np.transpose(A), A)\n",
    "\n",
    "\n",
    "def f_Ax(x):\n",
    "    return np.matmul(A, x.reshape(-1, 1)).reshape(-1)\n",
    "\n",
    "\n",
    "b = np.random.rand(8)\n",
    "\n",
    "w = np.matmul(np.matmul(inv(np.matmul(np.transpose(A), A)),\n",
    "                        np.transpose(A)), b.reshape((-1, 1))).reshape(-1)\n",
    "print(w)\n",
    "print(conjugate_gradient(f_Ax, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compile a function that exports network weights as a vector\n",
    "flat_weights = tf.concat([tf.reshape(var, [-1]) for var in weights], axis=0)\n",
    "\n",
    "# ... and another function that imports vector back into network weights\n",
    "flat_weights_placeholder = tf.placeholder(tf.float32, shape=(None,))\n",
    "assigns = slice_vector(flat_weights_placeholder, weight_shapes)\n",
    "\n",
    "load_flat_weights = [w.assign(ph) for w, ph in zip(weights, assigns)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Step 5: Main TRPO loop\n",
    "\n",
    "Here we will train our network!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "from itertools import count\n",
    "from collections import OrderedDict\n",
    "\n",
    "# this is hyperparameter of TRPO. It controls how big KL divergence may be between old and new policy every step.\n",
    "max_kl = 0.01\n",
    "cg_damping = 0.1  # This parameters regularize addition to\n",
    "numeptotal = 0  # this is number of episodes that we played.\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "for i in count(1):\n",
    "\n",
    "    print(\"\\n********** Iteration %i ************\" % i)\n",
    "\n",
    "    # Generating paths.\n",
    "    print(\"Rollout\")\n",
    "    paths = rollout(env, act)\n",
    "    print(\"Made rollout\")\n",
    "\n",
    "    # Updating policy.\n",
    "    observations = np.concatenate([path[\"observations\"] for path in paths])\n",
    "    actions = np.concatenate([path[\"actions\"] for path in paths])\n",
    "    returns = np.concatenate([path[\"cumulative_returns\"] for path in paths])\n",
    "    old_probs = np.concatenate([path[\"policy\"] for path in paths])\n",
    "    inputs_batch = [observations, actions, returns, old_probs]\n",
    "    feed_dict = {observations_ph: observations,\n",
    "                 actions_ph: actions,\n",
    "                 old_probs_ph: old_probs,\n",
    "                 cummulative_returns_ph: returns,\n",
    "                 }\n",
    "    old_weights = sess.run(flat_weights)\n",
    "\n",
    "    def fisher_vector_product(p):\n",
    "        \"\"\"gets intermediate grads (p) and computes fisher*vector \"\"\"\n",
    "        feed_dict[conjugate_grad_intermediate_vector] = p\n",
    "        return sess.run(fisher_vec_prod, feed_dict) + cg_damping * p\n",
    "\n",
    "    flat_grad = sess.run(flat_grad_surr, feed_dict)\n",
    "\n",
    "    stepdir = conjugate_gradient(fisher_vector_product, -flat_grad)\n",
    "    shs = .5 * stepdir.dot(fisher_vector_product(stepdir))\n",
    "    lm = np.sqrt(shs / max_kl)\n",
    "    fullstep = stepdir / lm\n",
    "\n",
    "    # Compute new weights with linesearch in the direction we found with CG\n",
    "\n",
    "    def losses_f(flat_weights):\n",
    "        feed_dict[flat_weights_placeholder] = flat_weights\n",
    "        sess.run(load_flat_weights, feed_dict)\n",
    "        return sess.run(losses, feed_dict)\n",
    "\n",
    "    new_weights = linesearch(losses_f, old_weights, fullstep, max_kl)\n",
    "    feed_dict[flat_weights_placeholder] = new_weights\n",
    "    sess.run(load_flat_weights, feed_dict)\n",
    "\n",
    "    # Report current progress\n",
    "    L_surr, kl, entropy = sess.run(losses, feed_dict)\n",
    "    episode_rewards = np.array([path[\"rewards\"].sum() for path in paths])\n",
    "\n",
    "    stats = OrderedDict()\n",
    "    numeptotal += len(episode_rewards)\n",
    "    stats[\"Total number of episodes\"] = numeptotal\n",
    "    stats[\"Average sum of rewards per episode\"] = episode_rewards.mean()\n",
    "    stats[\"Std of rewards per episode\"] = episode_rewards.std()\n",
    "    stats[\"Entropy\"] = entropy\n",
    "    stats[\"Time elapsed\"] = \"%.2f mins\" % ((time.time() - start_time)/60.)\n",
    "    stats[\"KL between old and new distribution\"] = kl\n",
    "    stats[\"Surrogate loss\"] = L_surr\n",
    "    for k, v in stats.items():\n",
    "        print(k + \": \" + \" \" * (40 - len(k)) + str(v))\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework option I: better sampling (10+pts)\n",
    "\n",
    "In this section, you're invited to implement a better rollout strategy called _vine_.\n",
    "\n",
    "![img](https://s17.postimg.cc/i90chxgvj/vine.png)\n",
    "\n",
    "In most gym environments, you can actually backtrack by using states. You can find a wrapper that saves/loads states in [the mcts seminar](https://github.com/yandexdataschool/Practical_RL/blob/master/week10_planning/seminar_MCTS.ipynb).\n",
    "\n",
    "You can read more about in the [TRPO article](https://arxiv.org/abs/1502.05477) in section 5.2.\n",
    "\n",
    "The goal here is to implement such rollout policy (we recommend using tree data structure like in the seminar above).\n",
    "Then you can assign cummulative rewards similar to `get_cummulative_rewards`, but for a tree.\n",
    "\n",
    "__bonus task__ - parallelize samples using multiple cores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Homework option II (10+pts)\n",
    "\n",
    "Let's use TRPO to train evil robots! (pick any of two)\n",
    "* [MuJoCo robots](https://gym.openai.com/envs#mujoco)\n",
    "* [Box2d robot](https://gym.openai.com/envs/BipedalWalker-v2)\n",
    "\n",
    "The catch here is that those environments have continuous action spaces. \n",
    "\n",
    "Luckily, TRPO is a policy gradient method, so it's gonna work for any parametric $\\pi_\\theta(a|s)$. We recommend starting with gaussian policy:\n",
    "\n",
    "$$\\pi_\\theta(a|s) = N(\\mu_\\theta(s),\\sigma^2_\\theta(s)) = {1 \\over \\sqrt { 2 \\pi {\\sigma^2}_\\theta(s) } } e^{ (a - \n",
    "\\mu_\\theta(s))^2 \\over 2 {\\sigma^2}_\\theta(s) } $$\n",
    "\n",
    "In the $\\sqrt { 2 \\pi {\\sigma^2}_\\theta(s) }$ clause, $\\pi$ means ~3.1415926, not agent's policy.\n",
    "\n",
    "This essentially means that you will need two output layers:\n",
    "* $\\mu_\\theta(s)$, a dense layer with linear activation\n",
    "* ${\\sigma^2}_\\theta(s)$, a dense layer with activation tf.exp (to make it positive; like rho from bandits)\n",
    "\n",
    "For multidimensional actions, you can use fully factorized gaussian (basically a vector of gaussians).\n",
    "\n",
    "__bonus task__: compare performance of continuous action space method to action space discretization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python",
   "pygments_lexer": "ipython3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}