Upside-Down.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch \n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Categorical\n",
    "import torch.nn.functional as F\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import copy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# init Environment\n",
    "env = gym.make(\"CartPole-v0\")\n",
    "action_space = env.action_space.n\n",
    "state_space = env.observation_space.shape[0]\n",
    "max_reward = 200\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "horizon_scale = 0.02\n",
    "return_scale = 0.02\n",
    "replay_size = 700\n",
    "n_warm_up_episodes = 50\n",
    "n_updates_per_iter = 100\n",
    "n_episodes_per_iter = 15\n",
    "last_few = 50\n",
    "batch_size = 256"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Behavior Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BF(nn.Module):\n",
    "    def __init__(self, state_space, action_space, hidden_size, seed):\n",
    "        super(BF, self).__init__()\n",
    "        torch.manual_seed(seed)\n",
    "        self.actions = np.arange(action_space)\n",
    "        self.action_space = action_space\n",
    "        self.fc1 = nn.Linear(state_space, hidden_size)\n",
    "        self.commands = nn.Linear(2, hidden_size)\n",
    "        self.fc2 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc3 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc4 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc5 = nn.Linear(hidden_size, action_space)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        \n",
    "    def forward(self, state, command):       \n",
    "               \n",
    "        out = self.sigmoid(self.fc1(state))\n",
    "        command_out = self.sigmoid(self.commands(command))\n",
    "        out = out * command_out\n",
    "        out = torch.relu(self.fc2(out))\n",
    "        out = torch.relu(self.fc3(out))\n",
    "        out = torch.relu(self.fc4(out))\n",
    "        out = self.fc5(out)\n",
    "        \n",
    "        return out\n",
    "    \n",
    "    def action(self, state, desire, horizon):\n",
    "        \"\"\"\n",
    "        Samples the action based on their probability\n",
    "        \"\"\"\n",
    "        command = torch.cat((desire*return_scale,horizon*horizon_scale), dim=-1)\n",
    "        action_prob = self.forward(state, command)\n",
    "        probs = torch.softmax(action_prob, dim=-1)\n",
    "        m = Categorical(probs)\n",
    "        action = m.sample()\n",
    "        return action\n",
    "    def greedy_action(self, state, desire, horizon):\n",
    "        \"\"\"\n",
    "        Returns the greedy action \n",
    "        \"\"\"\n",
    "        command = torch.cat((desire*return_scale,horizon*horizon_scale), dim=-1)\n",
    "        action_prob = self.forward(state, command)\n",
    "        probs = torch.softmax(action_prob, dim=-1)\n",
    "        action = torch.argmax(probs).item()\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay Buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer():\n",
    "    def __init__(self, max_size):\n",
    "        self.max_size = max_size\n",
    "        self.buffer = []\n",
    "        \n",
    "        \n",
    "    def add_sample(self, states, actions, rewards):\n",
    "        episode = {\"states\": states, \"actions\":actions, \"rewards\": rewards, \"summed_rewards\":sum(rewards)}\n",
    "        self.buffer.append(episode)\n",
    "        \n",
    "    \n",
    "    def sort(self):\n",
    "        #sort buffer\n",
    "        self.buffer = sorted(self.buffer, key = lambda i: i[\"summed_rewards\"],reverse=True)\n",
    "        # keep the max buffer size\n",
    "        self.buffer = self.buffer[:self.max_size]\n",
    "    \n",
    "    def get_random_samples(self, batch_size):\n",
    "        self.sort()\n",
    "        idxs = np.random.randint(0, len(self.buffer), batch_size)\n",
    "        batch = [self.buffer[idx] for idx in idxs]\n",
    "        return batch\n",
    "    \n",
    "    def get_nbest(self, n):\n",
    "        self.sort()\n",
    "        return self.buffer[:n]\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### init replay buffer with n-warmup runs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "buffer = ReplayBuffer(replay_size)\n",
    "bf = BF(state_space, action_space, 64, 1).to(device)\n",
    "optimizer = optim.Adam(params=bf.parameters(), lr=1e-3)\n",
    "\n",
    "samples = []\n",
    "#initial command\n",
    "init_desired_reward = 1 \n",
    "init_time_horizon = 1 \n",
    "\n",
    "for i in range(n_warm_up_episodes):\n",
    "    desired_return = torch.FloatTensor([init_desired_reward])\n",
    "    desired_time_horizon = torch.FloatTensor([init_time_horizon])\n",
    "    state = env.reset()\n",
    "    states = []\n",
    "    actions = []\n",
    "    rewards = []\n",
    "    while True:\n",
    "        action = bf.action(torch.from_numpy(state).float().to(device), desired_return.to(device), desired_time_horizon.to(device))\n",
    "        next_state, reward, done, _ = env.step(action.cpu().numpy())\n",
    "        states.append(torch.from_numpy(state).float())\n",
    "        actions.append(action)\n",
    "        rewards.append(reward)\n",
    "        \n",
    "        state = next_state\n",
    "        desired_return -= reward\n",
    "        desired_time_horizon -= 1\n",
    "        desired_time_horizon = torch.FloatTensor([np.maximum(desired_time_horizon, 1).item()])\n",
    "\n",
    "        if done:\n",
    "            break \n",
    "        \n",
    "    buffer.add_sample(states, actions, rewards)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## OBSERVE THE WEIGHTS before training\n",
    "#for p in bf.parameters():\n",
    "#    print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FUNCTIONS FOR Sampling exploration commands\n",
    "\n",
    "def sampling_exploration( top_X_eps = last_few):\n",
    "    \"\"\"\n",
    "    This function calculates the new desired reward and new desired horizon based on the replay buffer.\n",
    "    New desired horizon is calculted by the mean length of the best last X episodes. \n",
    "    New desired reward is sampled from a uniform distribution given the mean and the std calculated from the last best X performances.\n",
    "    where X is the hyperparameter last_few.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    top_X = buffer.get_nbest(last_few)\n",
    "    #The exploratory desired horizon dh0 is set to the mean of the lengths of the selected episodes\n",
    "    new_desired_horizon = np.mean([len(i[\"states\"]) for i in top_X])\n",
    "    # save all top_X cumulative returns in a list \n",
    "    returns = [i[\"summed_rewards\"] for i in top_X]\n",
    "    # from these returns calc the mean and std\n",
    "    mean_returns = np.mean(returns)\n",
    "    std_returns = np.std(returns)\n",
    "    # sample desired reward from a uniform distribution given the mean and the std\n",
    "    new_desired_reward = np.random.uniform(mean_returns, mean_returns+std_returns)\n",
    "\n",
    "    return torch.FloatTensor([new_desired_reward])  , torch.FloatTensor([new_desired_horizon]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FUNCTIONS FOR TRAINING\n",
    "def select_time_steps(saved_episode):\n",
    "    \"\"\"\n",
    "    Given a saved episode from the replay buffer this function samples random time steps (t1 and t2) in that episode:\n",
    "    T = max time horizon in that episode\n",
    "    Returns t1, t2 and T \n",
    "    \"\"\"\n",
    "    # Select times in the episode:\n",
    "    T = len(saved_episode[\"states\"]) # episode max horizon \n",
    "    t1 = np.random.randint(0,T-1)\n",
    "    t2 = np.random.randint(t1+1,T)\n",
    "\n",
    "    return t1, t2, T\n",
    "\n",
    "def create_training_input(episode, t1, t2):\n",
    "    \"\"\"\n",
    "    Based on the selected episode and the given time steps this function returns 4 values:\n",
    "    1. state at t1\n",
    "    2. the desired reward: sum over all rewards from t1 to t2\n",
    "    3. the time horizont: t2 -t1\n",
    "    \n",
    "    4. the target action taken at t1\n",
    "    \n",
    "    buffer episodes are build like [cumulative episode reward, states, actions, rewards]\n",
    "    \"\"\"\n",
    "    state = episode[\"states\"][t1] \n",
    "    desired_reward = sum(episode[\"rewards\"][t1:t2])\n",
    "    time_horizont = t2-t1\n",
    "    action = episode[\"actions\"][t1]\n",
    "    return state, desired_reward, time_horizont, action\n",
    "\n",
    "def create_training_examples(batch_size):\n",
    "    \"\"\"\n",
    "    Creates a data set of training examples that can be used to create a data loader for training.\n",
    "    ============================================================\n",
    "    1. for the given batch_size episode idx are randomly selected\n",
    "    2. based on these episodes t1 and t2 are samples for each selected episode \n",
    "    3. for the selected episode and sampled t1 and t2 trainings values are gathered\n",
    "    ______________________________________________________________\n",
    "    Output are two numpy arrays in the length of batch size:\n",
    "    Input Array for the Behavior function - consisting of (state, desired_reward, time_horizon)\n",
    "    Output Array with the taken actions \n",
    "    \"\"\"\n",
    "    input_array = []\n",
    "    output_array = []\n",
    "    # select randomly episodes from the buffer\n",
    "    episodes = buffer.get_random_samples(batch_size)\n",
    "    for ep in episodes:\n",
    "        #select time stamps\n",
    "        t1, t2, T = select_time_steps(ep)\n",
    "        # For episodic tasks they set t2 to T:\n",
    "        t2 = T\n",
    "        state, desired_reward, time_horizont, action = create_training_input(ep, t1, t2)\n",
    "        input_array.append(torch.cat([state, torch.FloatTensor([desired_reward]), torch.FloatTensor([time_horizont])]))\n",
    "        output_array.append(action)\n",
    "    return input_array, output_array\n",
    "\n",
    "def train_behavior_function(batch_size):\n",
    "    \"\"\"\n",
    "    Trains the BF with on a cross entropy loss were the inputs are the action probabilities based on the state and command.\n",
    "    The targets are the actions appropriate to the states from the replay buffer.\n",
    "    \"\"\"\n",
    "    X, y = create_training_examples(batch_size)\n",
    "\n",
    "    X = torch.stack(X)\n",
    "    state = X[:,0:state_space]\n",
    "    d = X[:,state_space:state_space+1]\n",
    "    h = X[:,state_space+1:state_space+2]\n",
    "    command = torch.cat((d*return_scale,h*horizon_scale), dim=-1)\n",
    "    y = torch.stack(y).long()\n",
    "    y_ = bf(state.to(device), command.to(device)).float()\n",
    "    optimizer.zero_grad()\n",
    "    pred_loss = F.cross_entropy(y_, y)   \n",
    "    pred_loss.backward()\n",
    "    optimizer.step()\n",
    "    return pred_loss.detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(desired_return = torch.FloatTensor([init_desired_reward]), desired_time_horizon = torch.FloatTensor([init_time_horizon])):\n",
    "    \"\"\"\n",
    "    Runs one episode of the environment to evaluate the bf.\n",
    "    \"\"\"\n",
    "    state = env.reset()\n",
    "    rewards = 0\n",
    "    while True:\n",
    "        state = torch.FloatTensor(state)\n",
    "        action = bf.action(state.to(device), desired_return.to(device), desired_time_horizon.to(device))\n",
    "        state, reward, done, _ = env.step(action.cpu().numpy()) \n",
    "        rewards += reward\n",
    "        desired_return = min(desired_return - reward, torch.FloatTensor([max_reward]))\n",
    "        desired_time_horizon = max(desired_time_horizon - 1, torch.FloatTensor([1]))\n",
    "        \n",
    "        if done:\n",
    "            break \n",
    "    return rewards\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Algorithm 2 - Generates an Episode unsing the Behavior Function:\n",
    "def generate_episode(desired_return = torch.FloatTensor([init_desired_reward]), desired_time_horizon = torch.FloatTensor([init_time_horizon])):    \n",
    "    \"\"\"\n",
    "    Generates more samples for the replay buffer.\n",
    "    \"\"\"\n",
    "    state = env.reset()\n",
    "    states = []\n",
    "    actions = []\n",
    "    rewards = []\n",
    "    while True:\n",
    "        state = torch.FloatTensor(state)\n",
    "\n",
    "        action = bf.action(state.to(device), desired_return.to(device), desired_time_horizon.to(device))\n",
    "        next_state, reward, done, _ = env.step(action.cpu().numpy())\n",
    "        states.append(state)\n",
    "        actions.append(action)\n",
    "        rewards.append(reward)\n",
    "        \n",
    "        state = next_state\n",
    "        desired_return -= reward\n",
    "        desired_time_horizon -= 1\n",
    "        desired_time_horizon = torch.FloatTensor([np.maximum(desired_time_horizon, 1).item()])\n",
    "        \n",
    "        if done:\n",
    "            break \n",
    "    return [states, actions, rewards]\n",
    "\n",
    "\n",
    "# Algorithm 1 - Upside - Down Reinforcement Learning \n",
    "def run_upside_down(max_episodes):\n",
    "    \"\"\"\n",
    "    \n",
    "    \"\"\"\n",
    "    all_rewards = []\n",
    "    losses = []\n",
    "    average_100_reward = []\n",
    "    desired_rewards_history = []\n",
    "    horizon_history = []\n",
    "    for ep in range(1, max_episodes+1):\n",
    "\n",
    "        # improve|optimize bf based on replay buffer\n",
    "        loss_buffer = []\n",
    "        for i in range(n_updates_per_iter):\n",
    "            bf_loss = train_behavior_function(batch_size)\n",
    "            loss_buffer.append(bf_loss)\n",
    "        bf_loss = np.mean(loss_buffer)\n",
    "        losses.append(bf_loss)\n",
    "        \n",
    "        # run x new episode and add to buffer\n",
    "        for i in range(n_episodes_per_iter):\n",
    "            \n",
    "            # Sample exploratory commands based on buffer\n",
    "            new_desired_reward, new_desired_horizon = sampling_exploration()\n",
    "            generated_episode = generate_episode(new_desired_reward, new_desired_horizon)\n",
    "            buffer.add_sample(generated_episode[0],generated_episode[1],generated_episode[2])\n",
    "            \n",
    "        new_desired_reward, new_desired_horizon = sampling_exploration()\n",
    "        # monitoring desired reward and desired horizon\n",
    "        desired_rewards_history.append(new_desired_reward.item())\n",
    "        horizon_history.append(new_desired_horizon.item())\n",
    "        \n",
    "        ep_rewards = evaluate(new_desired_reward, new_desired_horizon)\n",
    "        all_rewards.append(ep_rewards)\n",
    "        average_100_reward.append(np.mean(all_rewards[-100:]))\n",
    "        \n",
    "\n",
    "\n",
    "        print(\"\\rEpisode: {} | Rewards: {:.2f} | Mean_100_Rewards: {:.2f} | Loss: {:.2f}\".format(ep, ep_rewards, np.mean(all_rewards[-100:]), bf_loss), end=\"\", flush=True)\n",
    "        if ep % 100 == 0:\n",
    "            print(\"\\rEpisode: {} | Rewards: {:.2f} | Mean_100_Rewards: {:.2f} | Loss: {:.2f}\".format(ep, ep_rewards, np.mean(all_rewards[-100:]), bf_loss))\n",
    "            \n",
    "    return all_rewards, average_100_reward, desired_rewards_history, horizon_history, losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode: 100 | Rewards: 150.00 | Mean_100_Rewards: 126.77 | Loss: 0.59\n",
      "Episode: 200 | Rewards: 200.00 | Mean_100_Rewards: 191.36 | Loss: 0.59\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 7min 30s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "rewards, average, d, h, loss = run_upside_down(max_episodes=200)\n",
    "torch.save(bf.state_dict(), \"behaviorfunction.pth\")\n",
    "plt.figure(figsize=(15,8))\n",
    "plt.subplot(2,2,1)\n",
    "plt.title(\"Rewards\")\n",
    "plt.plot(rewards, label=\"rewards\")\n",
    "plt.plot(average, label=\"average100\")\n",
    "plt.legend()\n",
    "plt.subplot(2,2,2)\n",
    "plt.title(\"Loss\")\n",
    "plt.plot(loss)\n",
    "plt.subplot(2,2,3)\n",
    "plt.title(\"desired Rewards\")\n",
    "plt.plot(d)\n",
    "plt.subplot(2,2,4)\n",
    "plt.title(\"desired Horizon\")\n",
    "plt.plot(h)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SAVE MODEL\n",
    "name = \"model.pth\"\n",
    "torch.save(bf.state_dict(), name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "## OBSERVE THE WEIGHTS after training\n",
    "#for p in bf.parameters():\n",
    "#    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EVALUATION RUN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Desired rewards: 200.0 | after finishing one episode the agent received 200.0 rewards\n"
     ]
    }
   ],
   "source": [
    "DESIRED_REWARD = torch.FloatTensor([200]).to(device)\n",
    "DESIRED_HORIZON = torch.FloatTensor([200]).to(device)\n",
    "desired = DESIRED_REWARD.item()\n",
    "\n",
    "env = gym.make('CartPole-v0')\n",
    "env.reset()\n",
    "rewards = 0\n",
    "while True:\n",
    "    command = torch.cat((DESIRED_REWARD*return_scale,DESIRED_HORIZON*horizon_scale), dim=-1)\n",
    "\n",
    "    probs_logits = bf(torch.from_numpy(state).float().to(device), command)\n",
    "    probs = torch.softmax(probs_logits, dim=-1).detach().cpu()\n",
    "    action = torch.argmax(probs).item()\n",
    "    state, reward, done, info = env.step(action)\n",
    "    rewards += reward\n",
    "    DESIRED_REWARD -= reward\n",
    "    DESIRED_HORIZON -= 1\n",
    "    if done:\n",
    "        break\n",
    "\n",
    "print(\"Desired rewards: {} | after finishing one episode the agent received {} rewards\".format(desired, rewards))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}