LSMT_Value_PPO_Cartpole.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fb7520cf-a651-45b8-bd10-6a28a3d932b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ[\"KERAS_BACKEND\"] = \"tensorflow\"\n",
    "\n",
    "import keras\n",
    "from keras import layers\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import gymnasium as gym\n",
    "import scipy.signal\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from gymnasium.wrappers import FrameStack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ae5aad9e-a98c-4894-ad8d-edee84d24f4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def discounted_cumulative_sums(x, discount):\n",
    "    # Discounted cumulative sums of vectors for computing rewards-to-go and advantage estimates\n",
    "    return scipy.signal.lfilter([1], [1, float(-discount)], x[::-1], axis=0)[::-1]\n",
    "\n",
    "\n",
    "class Buffer:\n",
    "    # Buffer for storing trajectories\n",
    "    def __init__(self, observation_dimensions, size, gamma=0.99, lam=0.95):\n",
    "        # Buffer initialization\n",
    "        self.observation_buffer_actor = np.zeros(\n",
    "            (size, observation_dimensions), dtype=np.float32\n",
    "        )\n",
    "        self.observation_buffer_critic = np.zeros(\n",
    "            (size, 4, 4), dtype=np.float32\n",
    "        )\n",
    "        self.action_buffer = np.zeros(size, dtype=np.int32)\n",
    "        self.advantage_buffer = np.zeros(size, dtype=np.float32)\n",
    "        self.reward_buffer = np.zeros(size, dtype=np.float32)\n",
    "        self.return_buffer = np.zeros(size, dtype=np.float32)\n",
    "        self.value_buffer = np.zeros(size, dtype=np.float32)\n",
    "        self.logprobability_buffer = np.zeros(size, dtype=np.float32)\n",
    "        self.gamma, self.lam = gamma, lam\n",
    "        self.pointer, self.trajectory_start_index = 0, 0\n",
    "\n",
    "    def store(self, observation_actor, observation_critic, action, reward, value, logprobability):\n",
    "        # Append one step of agent-environment interaction\n",
    "        self.observation_buffer_actor[self.pointer] = observation_actor\n",
    "        self.observation_buffer_critic[self.pointer] = observation_critic\n",
    "        self.action_buffer[self.pointer] = action\n",
    "        self.reward_buffer[self.pointer] = reward\n",
    "        self.value_buffer[self.pointer] = value\n",
    "        self.logprobability_buffer[self.pointer] = logprobability\n",
    "        self.pointer += 1\n",
    "\n",
    "    def finish_trajectory(self, last_value=0):\n",
    "        # Finish the trajectory by computing advantage estimates and rewards-to-go\n",
    "        path_slice = slice(self.trajectory_start_index, self.pointer)\n",
    "        rewards = np.append(self.reward_buffer[path_slice], last_value)\n",
    "        values = np.append(self.value_buffer[path_slice], last_value)\n",
    "\n",
    "        deltas = rewards[:-1] + self.gamma * values[1:] - values[:-1]\n",
    "\n",
    "        self.advantage_buffer[path_slice] = discounted_cumulative_sums(\n",
    "            deltas, self.gamma * self.lam\n",
    "        )\n",
    "        self.return_buffer[path_slice] = discounted_cumulative_sums(\n",
    "            rewards, self.gamma\n",
    "        )[:-1]\n",
    "\n",
    "        self.trajectory_start_index = self.pointer\n",
    "\n",
    "    def get(self):\n",
    "        # Get all data of the buffer and normalize the advantages\n",
    "        self.pointer, self.trajectory_start_index = 0, 0\n",
    "        advantage_mean, advantage_std = (\n",
    "            np.mean(self.advantage_buffer),\n",
    "            np.std(self.advantage_buffer),\n",
    "        )\n",
    "        self.advantage_buffer = (self.advantage_buffer - advantage_mean) / advantage_std\n",
    "        return (\n",
    "            self.observation_buffer_actor,\n",
    "            self.observation_buffer_critic,\n",
    "            self.action_buffer,\n",
    "            self.advantage_buffer,\n",
    "            self.return_buffer,\n",
    "            self.logprobability_buffer,\n",
    "        )\n",
    "\n",
    "\n",
    "def mlp(x, sizes, activation=keras.activations.tanh, output_activation=None):\n",
    "    # Build a feedforward neural network\n",
    "    for size in sizes[:-1]:\n",
    "        x = layers.Dense(units=size, activation=activation)(x)\n",
    "    return layers.Dense(units=sizes[-1], activation=output_activation)(x)\n",
    "\n",
    "\n",
    "def logprobabilities(logits, a):\n",
    "    # Compute the log-probabilities of taking actions a by using the logits (i.e. the output of the actor)\n",
    "    logprobabilities_all = keras.ops.log_softmax(logits)\n",
    "    logprobability = keras.ops.sum(\n",
    "        keras.ops.one_hot(a, num_actions) * logprobabilities_all, axis=1\n",
    "    )\n",
    "    return logprobability\n",
    "\n",
    "\n",
    "seed_generator = keras.random.SeedGenerator(1337)\n",
    "\n",
    "\n",
    "# Sample action from actor\n",
    "@tf.function\n",
    "def sample_action(observation):\n",
    "    logits = actor(observation)\n",
    "    action = keras.ops.squeeze(\n",
    "        keras.random.categorical(logits, 1, seed=seed_generator), axis=1\n",
    "    )\n",
    "    return logits, action\n",
    "\n",
    "\n",
    "# Train the policy by maxizing the PPO-Clip objective\n",
    "@tf.function\n",
    "def train_policy(\n",
    "    observation_buffer, action_buffer, logprobability_buffer, advantage_buffer\n",
    "):\n",
    "    with tf.GradientTape() as tape:  # Record operations for automatic differentiation.\n",
    "        ratio = keras.ops.exp(\n",
    "            logprobabilities(actor(observation_buffer), action_buffer)\n",
    "            - logprobability_buffer\n",
    "        )\n",
    "        min_advantage = keras.ops.where(\n",
    "            advantage_buffer > 0,\n",
    "            (1 + clip_ratio) * advantage_buffer,\n",
    "            (1 - clip_ratio) * advantage_buffer,\n",
    "        )\n",
    "\n",
    "        policy_loss = -keras.ops.mean(\n",
    "            keras.ops.minimum(ratio * advantage_buffer, min_advantage)\n",
    "        )\n",
    "    policy_grads = tape.gradient(policy_loss, actor.trainable_variables)\n",
    "    policy_optimizer.apply_gradients(zip(policy_grads, actor.trainable_variables))\n",
    "\n",
    "    kl = keras.ops.mean(\n",
    "        logprobability_buffer\n",
    "        - logprobabilities(actor(observation_buffer), action_buffer)\n",
    "    )\n",
    "    kl = keras.ops.sum(kl)\n",
    "    return kl\n",
    "\n",
    "\n",
    "# Train the value function by regression on mean-squared error\n",
    "@tf.function\n",
    "def train_value_function(observation_buffer, return_buffer):\n",
    "    with tf.GradientTape() as tape:  # Record operations for automatic differentiation.\n",
    "        value_loss = keras.ops.mean((return_buffer - critic(observation_buffer)) ** 2)\n",
    "    value_grads = tape.gradient(value_loss, critic.trainable_variables)\n",
    "    value_optimizer.apply_gradients(zip(value_grads, critic.trainable_variables))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "376b34a7-0338-4e31-a8b9-dedea15a0d39",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters of the PPO algorithm\n",
    "steps_per_epoch = 120\n",
    "epochs = 12\n",
    "gamma = 0.99\n",
    "clip_ratio = 0.2\n",
    "policy_learning_rate = 3e-4\n",
    "value_function_learning_rate = 1e-3\n",
    "train_policy_iterations = 80\n",
    "train_value_iterations = 80\n",
    "lam = 0.97\n",
    "target_kl = 0.01\n",
    "hidden_sizes = (64, 64)\n",
    "\n",
    "# True if you want to render the environment\n",
    "render = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4ae6cfaf-9e07-4d9a-8826-1a4f2ef14475",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Box([[-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38]\n",
      " [-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38]\n",
      " [-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38]\n",
      " [-4.8000002e+00 -3.4028235e+38 -4.1887903e-01 -3.4028235e+38]], [[4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38]\n",
      " [4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38]\n",
      " [4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38]\n",
      " [4.8000002e+00 3.4028235e+38 4.1887903e-01 3.4028235e+38]], (4, 4), float32)\n"
     ]
    }
   ],
   "source": [
    "# Initialize the environment and get the dimensionality of the\n",
    "# observation space and the number of possible actions\n",
    "env = gym.make(\"CartPole-v1\")\n",
    "observation_dimensions = env.observation_space.shape[0]\n",
    "num_actions = env.action_space.n\n",
    "\n",
    "stacked_frames=4\n",
    "\n",
    "env = FrameStack(env, stacked_frames)\n",
    "print(env.observation_space)\n",
    "#flattening env again\n",
    "#env = gym.wrappers.FlattenObservation(env)\n",
    "#print(env.observation_space)\n",
    "\n",
    "# Initialize the buffer\n",
    "buffer = Buffer(observation_dimensions, steps_per_epoch)\n",
    "\n",
    "# Initialize the actor and the critic as keras models\n",
    "observation_input = keras.Input(shape=(observation_dimensions,), dtype=\"float32\")\n",
    "logits = mlp(observation_input, list(hidden_sizes) + [num_actions])\n",
    "actor = keras.Model(inputs=observation_input, outputs=logits)\n",
    "\n",
    "\n",
    "##CHANGING just! the value/critic neural network\n",
    "observation_input = keras.Input(shape=(None,4),  dtype=\"float32\")\n",
    "y = layers.LSTM(64, return_sequences=True, activation=\"relu\")\n",
    "y = y(observation_input)\n",
    "y = layers.LSTM(64)(y)\n",
    "val = layers.Dense(1)(y)\n",
    "\n",
    "#value = keras.ops.squeeze(mlp(observation_input, list(hidden_sizes) + [1]), axis=1)\n",
    "value = keras.ops.squeeze(val, axis=1)\n",
    "#print(f\"value is {value}\")\n",
    "\n",
    "critic = keras.Model(inputs=observation_input, outputs=value)\n",
    "\n",
    "\n",
    "#value = keras.ops.squeeze(mlp(observation_input, list(hidden_sizes) + [1]), axis=1)\n",
    "#critic = keras.Model(inputs=observation_input, outputs=value)\n",
    "\n",
    "# Initialize the policy and the value function optimizers\n",
    "policy_optimizer = keras.optimizers.Adam(learning_rate=policy_learning_rate)\n",
    "value_optimizer = keras.optimizers.Adam(learning_rate=value_function_learning_rate)\n",
    "\n",
    "# Initialize the observation, episode return and episode length\n",
    "observation, _ = env.reset()\n",
    "episode_return, episode_length = 0, 0\n",
    "\n",
    "\n",
    "mean_return_info_value_LSTM = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b979332d-8947-4c23-9447-aa576d731a81",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Epoch: 1. Mean Return: 40.0. Mean Length: 40.0\n",
      " Epoch: 2. Mean Return: 24.0. Mean Length: 24.0\n",
      " Epoch: 3. Mean Return: 20.0. Mean Length: 20.0\n",
      " Epoch: 4. Mean Return: 24.0. Mean Length: 24.0\n",
      " Epoch: 5. Mean Return: 60.0. Mean Length: 60.0\n",
      " Epoch: 6. Mean Return: 60.0. Mean Length: 60.0\n",
      " Epoch: 7. Mean Return: 60.0. Mean Length: 60.0\n",
      " Epoch: 8. Mean Return: 30.0. Mean Length: 30.0\n",
      " Epoch: 9. Mean Return: 60.0. Mean Length: 60.0\n",
      " Epoch: 10. Mean Return: 30.0. Mean Length: 30.0\n",
      " Epoch: 11. Mean Return: 40.0. Mean Length: 40.0\n",
      " Epoch: 12. Mean Return: 60.0. Mean Length: 60.0\n"
     ]
    }
   ],
   "source": [
    "# Iterate over the number of epochs\n",
    "for epoch in range(epochs):\n",
    "    # Initialize the sum of the returns, lengths and number of episodes for each epoch\n",
    "    sum_return = 0\n",
    "    sum_length = 0\n",
    "    num_episodes = 0\n",
    "\n",
    "    # Iterate over the steps of each epoch\n",
    "    for t in range(steps_per_epoch):\n",
    "        if render:\n",
    "            env.render()\n",
    "\n",
    "        \n",
    "        #print(f\"observation is {observation}\")\n",
    "        \n",
    "        # Get the logits, action, and take one step in the environment\n",
    "        #observation = np.array(observation)\n",
    "\n",
    "        #print(f\"observation, now an array, is {observation}\")\n",
    "\n",
    "        observation = np.array(observation)\n",
    "        observation = observation.reshape(4, 4)\n",
    "        #print(f\"observationa after reshape is {observation}\")\n",
    "        #print(f\"observation[0] after reshape is {observation[0]}\")\n",
    "        \n",
    "        observation_actor = observation[0]\n",
    "        observation_actor = observation_actor.reshape(1,4)\n",
    "        #print(f\"observation for the actor is is {observation_actor}\")\n",
    "        observation = observation.reshape(1, 4, 4)\n",
    "        #print(f\"observation for the critic is {observation}\")\n",
    "        \n",
    "        logits, action = sample_action(observation_actor)\n",
    "        #observation_actor = observation[0]\n",
    "        #logits, action = sample_action(observation)\n",
    "        observation_new, reward, done, _, _ = env.step(action[0].numpy())\n",
    "        episode_return += reward\n",
    "        episode_length += 1\n",
    "\n",
    "        # Get the value and log-probability of the action\n",
    "        value_t = critic(observation)\n",
    "        logprobability_t = logprobabilities(logits, action)\n",
    "\n",
    "        # Store obs, act, rew, v_t, logp_pi_t\n",
    "        buffer.store(observation_actor, observation, action, reward, value_t, logprobability_t)\n",
    "\n",
    "        # Update the observation\n",
    "        observation = np.array(observation_new)\n",
    "\n",
    "        # Finish trajectory if reached to a terminal state\n",
    "        terminal = done\n",
    "        if terminal or (t == steps_per_epoch - 1):\n",
    "            last_value = 0 if done else critic(observation.reshape(1, 4, 4))\n",
    "            #last_value = 0 if done else critic(observation)\n",
    "            buffer.finish_trajectory(last_value)\n",
    "            sum_return += episode_return\n",
    "            sum_length += episode_length\n",
    "            num_episodes += 1\n",
    "            observation, _ = env.reset()\n",
    "            episode_return, episode_length = 0, 0\n",
    "\n",
    "    # Get values from the buffer\n",
    "    (\n",
    "        observation_buffer_actor,\n",
    "        observation_buffer_critic,\n",
    "        action_buffer,\n",
    "        advantage_buffer,\n",
    "        return_buffer,\n",
    "        logprobability_buffer,\n",
    "    ) = buffer.get()\n",
    "\n",
    "    # Update the policy and implement early stopping using KL divergence\n",
    "    for _ in range(train_policy_iterations):\n",
    "        kl = train_policy(\n",
    "            observation_buffer_actor, action_buffer, logprobability_buffer, advantage_buffer\n",
    "        )\n",
    "        if kl > 1.5 * target_kl:\n",
    "            # Early Stopping\n",
    "            break\n",
    "\n",
    "    # Update the value function\n",
    "    for _ in range(train_value_iterations):\n",
    "        train_value_function(observation_buffer_critic, return_buffer)\n",
    "\n",
    "   \n",
    "    #mean_return_info[epoch] = ((sum_return/num_episodes), epoch+1)\n",
    "\n",
    "    mean_return_info_value_LSTM.append([epoch, (sum_return / num_episodes)])\n",
    "\n",
    "    # Print mean return and length for each epoch\n",
    "    print(\n",
    "        f\" Epoch: {epoch + 1}. Mean Return: {sum_return / num_episodes}. Mean Length: {sum_length / num_episodes}\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4401145c-455c-4a8b-8b3d-f0fc299f6e49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x295cf2150>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = []\n",
    "y = []\n",
    "for i in range(epochs):\n",
    "    print(i)\n",
    "    x.append(mean_return_info[i][0])\n",
    "    y.append(mean_return_info[i][1])\n",
    "    i+=1\n",
    "    \n",
    "plt.plot(x, y, 'r', label=\"Value LSTM\")\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Mean Return')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f2b0383-49d2-4657-934c-e2dc03711f80",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "29c1d642-9563-4770-9c2d-61366a6a4c2d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c440f33c-2c24-4610-890d-5d766ece15a3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}