TensorflowRL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "i0iA0nubwpUX"
   },
   "source": [
    "<img src=\"./images/gym_CartPole.gif\" width=\"700\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iAO1TBxqwpUX"
   },
   "source": [
    "## 3. Deep Q-learning with PQC Q-function approximators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9uEimdpHwpUY"
   },
   "source": [
    "In this section, you will move to the implementation of the deep Q-learning algorithm presented in <a href=\"https://arxiv.org/abs/2103.15084\" class=\"external\">[2]</a>. As opposed to a policy-gradient approach, the deep Q-learning method uses a PQC to approximate the Q-function of the agent. That is, the PQC defines a function approximator:\n",
    "$$ Q_\\theta(s,a) = \\langle O_a \\rangle_{s,\\theta} $$\n",
    "where $\\langle O_a \\rangle_{s,\\theta}$ are expectation values of observables $O_a$ (one per action) measured at the ouput of the PQC.\n",
    "\n",
    "These Q-values are updated using a loss function derived from Q-learning:\n",
    "$$ \\mathcal{L}(\\theta) = \\frac{1}{|\\mathcal{B}|}\\sum_{s,a,r,s' \\in \\mathcal{B}} \\left(Q_\\theta(s,a) - [r +\\max_{a'} Q_{\\theta'}(s',a')]\\right)^2$$\n",
    "for a batch $\\mathcal{B}$ of $1$-step interactions $(s,a,r,s')$ with the environment, sampled from the replay memory, and parameters $\\theta'$ specifying the target PQC (i.e., a copy of the main PQC, whose parameters are sporadically copied from the main PQC throughout learning)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nTyRzuDYwpUY"
   },
   "source": [
    "You can adopt the same observables used in <a href=\"https://arxiv.org/abs/2103.15084\" class=\"external\">[2]</a> for CartPole, namely a $Z_0Z_1$ Pauli product for action $0$ and a $Z_2Z_3$ Pauli product for action $1$. Both observables are re-scaled so their expectation values are in $[0,1]$ and weighted by an action-specific weight. To implement the re-scaling and weighting of the Pauli products, you can define again an extra `tf.keras.layers.Layer` that stores the action-specific weights and applies them multiplicatively on the expectation values $\\left(1+\\langle Z_0Z_1 \\rangle_{s,\\theta}\\right)/2$ and $\\left(1+\\langle Z_2Z_3 \\rangle_{s,\\theta}\\right)/2$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mRunning cells with 'c:\\Users\\mgabi\\AppData\\Local\\Programs\\Python\\Python311\\python.exe' requires the ipykernel package.\n",
      "\u001b[1;31mRun the following command to install 'ipykernel' into the Python environment. \n",
      "\u001b[1;31mCommand: 'c:/Users/mgabi/AppData/Local/Programs/Python/Python311/python.exe -m pip install ipykernel -U --user --force-reinstall'"
     ]
    }
   ],
   "source": [
    "# Update package resources to account for version changes.\n",
    "import importlib, pkg_resources\n",
    "importlib.reload(pkg_resources)\n",
    "\n",
    "import tensorflow as tf\n",
    "import tensorflow_quantum as tfq\n",
    "\n",
    "import gym, cirq, sympy\n",
    "import numpy as np\n",
    "from functools import reduce\n",
    "from collections import deque, defaultdict\n",
    "import matplotlib.pyplot as plt\n",
    "from cirq.contrib.svg import SVGCircuit\n",
    "tf.get_logger().setLevel('ERROR')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "id": "MX5l96qywpUY"
   },
   "outputs": [],
   "source": [
    "class Rescaling(tf.keras.layers.Layer):\n",
    "    def __init__(self, input_dim):\n",
    "        super(Rescaling, self).__init__()\n",
    "        self.input_dim = input_dim\n",
    "        self.w = tf.Variable(\n",
    "            initial_value=tf.ones(shape=(1,input_dim)), dtype=\"float32\",\n",
    "            trainable=True, name=\"obs-weights\")\n",
    "\n",
    "    def call(self, inputs):\n",
    "        return tf.math.multiply((inputs+1)/2, tf.repeat(self.w,repeats=tf.shape(inputs)[0],axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReUploadingPQC(tf.keras.layers.Layer):\n",
    "    \"\"\"\n",
    "    Performs the transformation (s_1, ..., s_d) -> (theta_1, ..., theta_N, lmbd[1][1]s_1, ..., lmbd[1][M]s_1,\n",
    "        ......., lmbd[d][1]s_d, ..., lmbd[d][M]s_d) for d=input_dim, N=theta_dim and M=n_layers.\n",
    "    An activation function from tf.keras.activations, specified by `activation` ('linear' by default) is\n",
    "        then applied to all lmbd[i][j]s_i.\n",
    "    All angles are finally permuted to follow the alphabetical order of their symbol names, as processed\n",
    "        by the ControlledPQC.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, qubits, n_layers, observables, activation=\"linear\", name=\"re-uploading_PQC\"):\n",
    "        super(ReUploadingPQC, self).__init__(name=name)\n",
    "        self.n_layers = n_layers\n",
    "        self.n_qubits = len(qubits)\n",
    "\n",
    "        circuit, theta_symbols, input_symbols = generate_circuit(qubits, n_layers)\n",
    "\n",
    "        theta_init = tf.random_uniform_initializer(minval=0.0, maxval=np.pi)\n",
    "        self.theta = tf.Variable(\n",
    "            initial_value=theta_init(shape=(1, len(theta_symbols)), dtype=\"float32\"),\n",
    "            trainable=True, name=\"thetas\"\n",
    "        )\n",
    "\n",
    "        lmbd_init = tf.ones(shape=(self.n_qubits * self.n_layers,))\n",
    "        self.lmbd = tf.Variable(\n",
    "            initial_value=lmbd_init, dtype=\"float32\", trainable=True, name=\"lambdas\"\n",
    "        )\n",
    "\n",
    "        # Define explicit symbol order.\n",
    "        symbols = [str(symb) for symb in theta_symbols + input_symbols]\n",
    "        self.indices = tf.constant([symbols.index(a) for a in sorted(symbols)])\n",
    "\n",
    "        self.activation = activation\n",
    "        self.empty_circuit = tfq.convert_to_tensor([cirq.Circuit()])\n",
    "        self.computation_layer = tfq.layers.ControlledPQC(circuit, observables)        \n",
    "\n",
    "    def call(self, inputs):\n",
    "        # inputs[0] = encoding data for the state.\n",
    "        batch_dim = tf.gather(tf.shape(inputs[0]), 0)\n",
    "        tiled_up_circuits = tf.repeat(self.empty_circuit, repeats=batch_dim)\n",
    "        tiled_up_thetas = tf.tile(self.theta, multiples=[batch_dim, 1])\n",
    "        tiled_up_inputs = tf.tile(inputs[0], multiples=[1, self.n_layers])\n",
    "        scaled_inputs = tf.einsum(\"i,ji->ji\", self.lmbd, tiled_up_inputs)\n",
    "        squashed_inputs = tf.keras.layers.Activation(self.activation)(scaled_inputs)\n",
    "\n",
    "        joined_vars = tf.concat([tiled_up_thetas, squashed_inputs], axis=1)\n",
    "        joined_vars = tf.gather(joined_vars, self.indices, axis=1)\n",
    "\n",
    "        return self.computation_layer([tiled_up_circuits, joined_vars])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_qubit_rotation(qubit, symbols):\n",
    "    \"\"\"\n",
    "    Returns Cirq gates that apply a rotation of the bloch sphere about the X,\n",
    "    Y and Z axis, specified by the values in `symbols`.\n",
    "    \"\"\"\n",
    "    return [cirq.rx(symbols[0])(qubit),\n",
    "            cirq.ry(symbols[1])(qubit),\n",
    "            cirq.rz(symbols[2])(qubit)]\n",
    "\n",
    "def entangling_layer(qubits, cx = False, ladder = False):\n",
    "    \"\"\"\n",
    "    Returns a layer of CZ entangling gates on `qubits` (arranged in a circular topology).\n",
    "    \"\"\"\n",
    "    cz_ops = [cirq.CZ(q0, q1) for q0, q1 in zip(qubits, qubits[1:])]\n",
    "    cz_ops += ([cirq.CZ(qubits[0], qubits[-1])] if len(qubits) != 2 else [])\n",
    "    \n",
    "    if cx:\n",
    "        ''' Returns a layer of CX entangling gates on `qubits` (arranged in a circular topology).'''\n",
    "        cz_ops = [cirq.CNOT(q0, q1) for q0, q1 in zip(qubits, qubits[1:])]\n",
    "        cz_ops += ([cirq.CNOT(qubits[0], qubits[-1])] if len(qubits) != 2 else [])\n",
    "\n",
    "        if ladder:\n",
    "            ''' Returns a layer of CX entangling gates on `qubits` (arranged in a ladder topology).'''\n",
    "            cz_ops = [cirq.CNOT(qubits[i], q1) for i in range(len(qubits)-1) for q1 in qubits[i+1:]]\n",
    "    if not cx and ladder:\n",
    "        ''' Returns a layer of CZ entangling gates on `qubits` (arranged in a ladder topology).'''\n",
    "        cz_ops = [cirq.CZ(qubits[i], q1) for i in range(len(qubits)-1) for q1 in qubits[i+1:]]\n",
    "            \n",
    "        \n",
    "    return cz_ops\n",
    "\n",
    "def generate_circuit(qubits, n_layers):\n",
    "    \"\"\"Prepares a data re-uploading circuit on `qubits` with `n_layers` layers.\"\"\"\n",
    "    # Number of qubits\n",
    "    n_qubits = len(qubits)\n",
    "\n",
    "    # Sympy symbols for variational angles\n",
    "    params = sympy.symbols(f'theta(0:{3*(n_layers+1)*n_qubits})')\n",
    "    params = np.asarray(params).reshape((n_layers + 1, n_qubits, 3))\n",
    "\n",
    "    # Sympy symbols for encoding angles\n",
    "    inputs = sympy.symbols(f'x(0:{n_layers})'+f'_(0:{n_qubits})')\n",
    "    inputs = np.asarray(inputs).reshape((n_layers, n_qubits))\n",
    "\n",
    "    # Define circuit\n",
    "    circuit = cirq.Circuit()\n",
    "    for l in range(n_layers):\n",
    "        # Variational layer\n",
    "        circuit += cirq.Circuit(one_qubit_rotation(q, params[l, i]) for i, q in enumerate(qubits))\n",
    "        circuit += entangling_layer(qubits)\n",
    "        # Encoding layer\n",
    "        circuit += cirq.Circuit(cirq.rx(inputs[l, i])(q) for i, q in enumerate(qubits))\n",
    "\n",
    "    # Last varitional layer\n",
    "    circuit += cirq.Circuit(one_qubit_rotation(q, params[n_layers, i]) for i,q in enumerate(qubits))\n",
    "\n",
    "    return circuit, list(params.flat), list(inputs.flat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oesnEQa7wpUY"
   },
   "source": [
    "Prepare the definition of your PQC and its observables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "cpV0PxZqwpUY"
   },
   "outputs": [],
   "source": [
    "n_qubits = 4 # Dimension of the state vectors in CartPole\n",
    "n_layers = 5 # Number of layers in the PQC\n",
    "n_actions = 2 # Number of actions in CartPole\n",
    "\n",
    "qubits = cirq.GridQubit.rect(1, n_qubits)\n",
    "ops = [cirq.Z(q) for q in qubits]\n",
    "observables = [ops[0]*ops[1], ops[2]*ops[3]] # Z_0*Z_1 for action 0 and Z_2*Z_3 for action 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JLMvQBXFwpUZ"
   },
   "source": [
    "Define a `tf.keras.Model` that, similarly to the PQC-policy model, constructs a Q-function approximator that is used to generate the main and target models of our Q-learning agent."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "PBGM6RHIwpUZ"
   },
   "outputs": [],
   "source": [
    "def generate_model_Qlearning(qubits, n_layers, n_actions, observables, target):\n",
    "    \"\"\"Generates a Keras model for a data re-uploading PQC Q-function approximator.\"\"\"\n",
    "\n",
    "    input_tensor = tf.keras.Input(shape=(len(qubits), ), dtype=tf.dtypes.float32, name='input')\n",
    "    re_uploading_pqc = ReUploadingPQC(qubits, n_layers, observables, activation='tanh')([input_tensor])\n",
    "    process = tf.keras.Sequential([Rescaling(len(observables))], name=target*\"Target\"+\"Q-values\")\n",
    "    Q_values = process(re_uploading_pqc)\n",
    "    model = tf.keras.Model(inputs=[input_tensor], outputs=Q_values)\n",
    "\n",
    "    return model\n",
    "\n",
    "model = generate_model_Qlearning(qubits, n_layers, n_actions, observables, False)\n",
    "model_target = generate_model_Qlearning(qubits, n_layers, n_actions, observables, True)\n",
    "\n",
    "model_target.set_weights(model.get_weights())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 232
    },
    "id": "57TxgIN5wpUZ",
    "outputId": "da6a3aee-1722-40b3-fae5-2972d8c2ed88"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot to work.')\n"
     ]
    }
   ],
   "source": [
    "tf.keras.utils.plot_model(model, show_shapes=True, dpi=70)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 232
    },
    "id": "jHp42R4twpUa",
    "outputId": "69a20e50-fde4-4634-897b-01edaeab420a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('You must install pydot (`pip install pydot`) and install graphviz (see instructions at https://graphviz.gitlab.io/download/) ', 'for plot_model/model_to_dot to work.')\n"
     ]
    }
   ],
   "source": [
    "tf.keras.utils.plot_model(model_target, show_shapes=True, dpi=70)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vricJOvXwpUa"
   },
   "source": [
    "You can now implement the deep Q-learning algorithm and test it on the CartPole-v1 environment. For the policy of the agent, you can use an $\\varepsilon$-greedy policy:\n",
    "$$ \\pi(a|s) =\n",
    "\\begin{cases}\n",
    "\\delta_{a,\\text{argmax}_{a'} Q_\\theta(s,a')}\\quad \\text{w.p.}\\quad 1 - \\varepsilon\\\\\n",
    "\\frac{1}{\\text{num_actions}}\\quad \\quad \\quad \\quad \\text{w.p.}\\quad \\varepsilon\n",
    "\\end{cases} $$\n",
    "where $\\varepsilon$ is multiplicatively decayed at each episode of interaction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sMteuedswpUb"
   },
   "source": [
    "Start by defining a function that performs an interaction step in the environment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "0L9cV26PwpUb"
   },
   "outputs": [],
   "source": [
    "def interact_env(state, model, epsilon, n_actions, env):\n",
    "    # Preprocess state\n",
    "    state_array = np.array(state) \n",
    "    state = tf.convert_to_tensor([state_array])\n",
    "\n",
    "    # Sample action\n",
    "    coin = np.random.random()\n",
    "    if coin > epsilon:\n",
    "        q_vals = model([state])\n",
    "        action = int(tf.argmax(q_vals[0]).numpy())\n",
    "    else:\n",
    "        action = np.random.choice(n_actions)\n",
    "\n",
    "    # Apply sampled action in the environment, receive reward and next state\n",
    "    next_state, reward, done, _ = env.step(action)\n",
    "    \n",
    "    interaction = {'state': state_array, 'action': action, 'next_state': next_state.copy(),\n",
    "                   'reward': reward, 'done':np.float32(done)}\n",
    "    \n",
    "    return interaction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oDiw3iJywpUb"
   },
   "source": [
    "and a function that updates the Q-function using a batch of interactions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "RR2DjesVwpUb"
   },
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def Q_learning_update(states, actions, rewards, next_states, done, model, gamma, n_actions):\n",
    "    states = tf.convert_to_tensor(states)\n",
    "    actions = tf.convert_to_tensor(actions)\n",
    "    rewards = tf.convert_to_tensor(rewards)\n",
    "    next_states = tf.convert_to_tensor(next_states)\n",
    "    done = tf.convert_to_tensor(done)\n",
    "\n",
    "    # Compute their target q_values and the masks on sampled actions\n",
    "    future_rewards = model_target([next_states])\n",
    "    target_q_values = rewards + (gamma * tf.reduce_max(future_rewards, axis=1)\n",
    "                                                   * (1.0 - done))\n",
    "    masks = tf.one_hot(actions, n_actions)\n",
    "\n",
    "    # Train the model on the states and target Q-values\n",
    "    with tf.GradientTape() as tape:\n",
    "        tape.watch(model.trainable_variables)\n",
    "        q_values = model([states])\n",
    "        q_values_masked = tf.reduce_sum(tf.multiply(q_values, masks), axis=1)\n",
    "        loss = tf.keras.losses.Huber()(target_q_values, q_values_masked)\n",
    "\n",
    "    # Backpropagation\n",
    "    grads = tape.gradient(loss, model.trainable_variables)\n",
    "    for optimizer, w in zip([optimizer_in, optimizer_var, optimizer_out], [w_in, w_var, w_out]):\n",
    "        optimizer.apply_gradients([(grads[w], model.trainable_variables[w])])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tfXHhqaPwpUb"
   },
   "source": [
    "Define the hyperparameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "SQ937aYPwpUc"
   },
   "outputs": [],
   "source": [
    "gamma = 0.99\n",
    "n_episodes = 2000\n",
    "\n",
    "# Define replay memory\n",
    "max_memory_length = 10000 # Maximum replay length\n",
    "replay_memory = deque(maxlen=max_memory_length)\n",
    "\n",
    "epsilon = 1.0  # Epsilon greedy parameter\n",
    "epsilon_min = 0.01  # Minimum epsilon greedy parameter\n",
    "decay_epsilon = 0.99 # Decay rate of epsilon greedy parameter\n",
    "batch_size = 16\n",
    "steps_per_update = 10 # Train the model every x steps\n",
    "steps_per_target_update = 30 # Update the target model every x steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AHsHnuHmwpUc"
   },
   "source": [
    "Prepare the optimizers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "713nl3oUwpUc"
   },
   "outputs": [],
   "source": [
    "optimizer_in = tf.keras.optimizers.Adam(learning_rate=0.001, amsgrad=True)\n",
    "optimizer_var = tf.keras.optimizers.Adam(learning_rate=0.001, amsgrad=True)\n",
    "optimizer_out = tf.keras.optimizers.Adam(learning_rate=0.1, amsgrad=True)\n",
    "\n",
    "# Assign the model parameters to each optimizer\n",
    "w_in, w_var, w_out = 1, 0, 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AwE0buDowpUd"
   },
   "source": [
    "Now implement the main training loop of the agent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TjjTamvywpUd"
   },
   "source": [
    "Note: This agent may need to simulate several million quantum circuits and can take as much as ~40 minutes to finish training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "er9fXHH_wpUd",
    "outputId": "b165066b-c239-4bf0-b444-7c710640241c",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 10/2000, average last 10 rewards 21.8\n",
      "Episode 20/2000, average last 10 rewards 23.9\n",
      "Episode 30/2000, average last 10 rewards 19.9\n",
      "Episode 40/2000, average last 10 rewards 23.3\n",
      "Episode 50/2000, average last 10 rewards 17.6\n",
      "Episode 60/2000, average last 10 rewards 22.4\n",
      "Episode 70/2000, average last 10 rewards 26.2\n",
      "Episode 80/2000, average last 10 rewards 23.1\n",
      "Episode 90/2000, average last 10 rewards 56.4\n",
      "Episode 100/2000, average last 10 rewards 39.4\n",
      "Episode 110/2000, average last 10 rewards 57.4\n",
      "Episode 120/2000, average last 10 rewards 50.7\n",
      "Episode 130/2000, average last 10 rewards 51.9\n",
      "Episode 140/2000, average last 10 rewards 51.6\n",
      "Episode 150/2000, average last 10 rewards 53.3\n",
      "Episode 160/2000, average last 10 rewards 41.7\n",
      "Episode 170/2000, average last 10 rewards 49.1\n",
      "Episode 180/2000, average last 10 rewards 65.6\n",
      "Episode 190/2000, average last 10 rewards 62.9\n",
      "Episode 200/2000, average last 10 rewards 50.0\n",
      "Episode 210/2000, average last 10 rewards 34.7\n",
      "Episode 220/2000, average last 10 rewards 48.8\n",
      "Episode 230/2000, average last 10 rewards 60.1\n",
      "Episode 240/2000, average last 10 rewards 57.0\n",
      "Episode 250/2000, average last 10 rewards 66.5\n",
      "Episode 260/2000, average last 10 rewards 57.2\n",
      "Episode 270/2000, average last 10 rewards 64.9\n",
      "Episode 280/2000, average last 10 rewards 64.8\n",
      "Episode 290/2000, average last 10 rewards 69.0\n",
      "Episode 300/2000, average last 10 rewards 62.3\n",
      "Episode 310/2000, average last 10 rewards 42.2\n",
      "Episode 320/2000, average last 10 rewards 62.4\n",
      "Episode 330/2000, average last 10 rewards 38.7\n",
      "Episode 340/2000, average last 10 rewards 60.4\n",
      "Episode 350/2000, average last 10 rewards 63.2\n",
      "Episode 360/2000, average last 10 rewards 47.9\n",
      "Episode 370/2000, average last 10 rewards 37.6\n",
      "Episode 380/2000, average last 10 rewards 40.5\n",
      "Episode 390/2000, average last 10 rewards 40.5\n",
      "Episode 400/2000, average last 10 rewards 53.0\n",
      "Episode 410/2000, average last 10 rewards 26.1\n",
      "Episode 420/2000, average last 10 rewards 26.4\n",
      "Episode 430/2000, average last 10 rewards 12.2\n",
      "Episode 440/2000, average last 10 rewards 24.1\n",
      "Episode 450/2000, average last 10 rewards 42.8\n",
      "Episode 460/2000, average last 10 rewards 54.8\n",
      "Episode 470/2000, average last 10 rewards 47.1\n",
      "Episode 480/2000, average last 10 rewards 31.3\n",
      "Episode 490/2000, average last 10 rewards 115.0\n",
      "Episode 500/2000, average last 10 rewards 95.1\n",
      "Episode 510/2000, average last 10 rewards 183.8\n",
      "Episode 520/2000, average last 10 rewards 201.9\n",
      "Episode 530/2000, average last 10 rewards 97.3\n",
      "Episode 540/2000, average last 10 rewards 109.3\n",
      "Episode 550/2000, average last 10 rewards 156.5\n",
      "Episode 560/2000, average last 10 rewards 108.5\n",
      "Episode 570/2000, average last 10 rewards 147.4\n",
      "Episode 580/2000, average last 10 rewards 132.6\n",
      "Episode 590/2000, average last 10 rewards 138.2\n",
      "Episode 600/2000, average last 10 rewards 167.4\n",
      "Episode 610/2000, average last 10 rewards 65.9\n",
      "Episode 620/2000, average last 10 rewards 164.9\n",
      "Episode 630/2000, average last 10 rewards 134.3\n",
      "Episode 640/2000, average last 10 rewards 174.6\n",
      "Episode 650/2000, average last 10 rewards 164.2\n",
      "Episode 660/2000, average last 10 rewards 205.8\n",
      "Episode 670/2000, average last 10 rewards 181.1\n",
      "Episode 680/2000, average last 10 rewards 149.9\n",
      "Episode 690/2000, average last 10 rewards 57.4\n",
      "Episode 700/2000, average last 10 rewards 193.1\n",
      "Episode 710/2000, average last 10 rewards 375.0\n",
      "Episode 720/2000, average last 10 rewards 500.0\n"
     ]
    }
   ],
   "source": [
    "env = gym.make(\"CartPole-v1\")\n",
    "    \n",
    "episode_reward_history = []\n",
    "step_count = 0\n",
    "for episode in range(n_episodes):\n",
    "    episode_reward = 0\n",
    "    state = env.reset()\n",
    "    \n",
    "    while True:\n",
    "        # Interact with env\n",
    "        interaction = interact_env(state, model, epsilon, n_actions, env)\n",
    "        \n",
    "        # Store interaction in the replay memory\n",
    "        replay_memory.append(interaction)\n",
    "        \n",
    "        state = interaction['next_state']\n",
    "        episode_reward += interaction['reward']\n",
    "        step_count += 1\n",
    "        \n",
    "        # Update model\n",
    "        if step_count % steps_per_update == 0:\n",
    "            # Sample a batch of interactions and update Q_function\n",
    "            training_batch = np.random.choice(replay_memory, size=batch_size)\n",
    "            Q_learning_update(np.asarray([x['state'] for x in training_batch]),\n",
    "                              np.asarray([x['action'] for x in training_batch]),\n",
    "                              np.asarray([x['reward'] for x in training_batch], dtype=np.float32),\n",
    "                              np.asarray([x['next_state'] for x in training_batch]),\n",
    "                              np.asarray([x['done'] for x in training_batch], dtype=np.float32),\n",
    "                              model, gamma, n_actions)\n",
    "        \n",
    "        # Update target model\n",
    "        if step_count % steps_per_target_update == 0:\n",
    "            model_target.set_weights(model.get_weights())\n",
    "        \n",
    "        # Check if the episode is finished\n",
    "        if interaction['done']:\n",
    "            break\n",
    "\n",
    "    # Decay epsilon\n",
    "    epsilon = max(epsilon * decay_epsilon, epsilon_min)\n",
    "    episode_reward_history.append(episode_reward)\n",
    "    if (episode+1)%10 == 0:\n",
    "        avg_rewards = np.mean(episode_reward_history[-10:])\n",
    "        print(\"Episode {}/{}, average last 10 rewards {}\".format(\n",
    "            episode+1, n_episodes, avg_rewards))\n",
    "        if avg_rewards >= 500.0:\n",
    "            break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BG8BWOSYwpUd"
   },
   "source": [
    "Plot the learning history of the agent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 334
    },
    "id": "sSRMtk-swpUe",
    "outputId": "a2a4c5a8-92cf-495a-da9d-6be0e8f673a2"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,5))\n",
    "plt.plot(episode_reward_history)\n",
    "plt.xlabel('Epsiode')\n",
    "plt.ylabel('Collected rewards')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f_7rJf0iwpUe"
   },
   "source": [
    "Similarly to the plot above, you should see that after ~1000 episodes, the performance of the agent gets close to optimal, i.e., 500 rewards per episode. Learning takes longer for Q-learning agents since the Q-function is a \"richer\" function to be learned than the policy."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "jxWGru_NwpUK",
    "_u3QBKbvwpUP",
    "X8X49f8owpUe"
   ],
   "name": "quantum_reinforcement_learning.ipynb",
   "provenance": []
  },
  "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.11.2"
  },
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}