{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "2kWo-GNlwpT6" }, "source": [ "##### Copyright 2021 The TensorFlow Authors." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "5w2rucWZwpUA" }, "outputs": [], "source": [ "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n", "# you may not use this file except in compliance with the License.\n", "# You may obtain a copy of the License at\n", "#\n", "# https://www.apache.org/licenses/LICENSE-2.0\n", "#\n", "# Unless required by applicable law or agreed to in writing, software\n", "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", "# See the License for the specific language governing permissions and\n", "# limitations under the License." ] }, { "cell_type": "markdown", "metadata": { "id": "GHebkma_wpUC" }, "source": [ "# Parametrized Quantum Circuits for Reinforcement Learning" ] }, { "cell_type": "markdown", "metadata": { "id": "xQf8eEUewpUD" }, "source": [ "\n", " \n", " \n", " \n", " \n", "
\n", " View on TensorFlow.org\n", " \n", " Run in Google Colab\n", " \n", " View source on GitHub\n", " \n", " Download notebook\n", "
" ] }, { "cell_type": "markdown", "metadata": { "id": "8NJTIUX_wpUE" }, "source": [ "Quantum computers have been shown to provide computational advantages in certain problem areas. The field of quantum reinforcement learning (QRL) aims to harness this boost by designing RL agents that rely on quantum models of computation.\n", "\n", "In this tutorial, you will implement two reinforcement learning algorithms based on parametrized/variational quantum circuits (PQCs or VQCs), namely a policy-gradient and a deep Q-learning implementation. These algorithms were introduced by [[1] Jerbi et al.](https://arxiv.org/abs/2103.05577) and [[2] Skolik et al.](https://arxiv.org/abs/2103.15084), respectively." ] }, { "cell_type": "markdown", "metadata": { "id": "bYkcUIu4wpUF" }, "source": [ "You will implement a PQC with data re-uploading in TFQ, and use it as:\n", "1. an RL policy trained with a policy-gradient method,\n", "2. a Q-function approximator trained with deep Q-learning,\n", "\n", "each solving [CartPole-v1](https://gymnasium.farama.org/environments/classic_control/cart_pole/), a benchmarking task from Gymnasium. Note that, as showcased in [[1]](https://arxiv.org/abs/2103.05577) and [[2]](https://arxiv.org/abs/2103.15084), these agents can also be used to solve other task-environment from Gymnasium, such as [FrozenLake-v1](https://gymnasium.farama.org/environments/toy_text/frozen_lake/), [MountainCar-v0](https://gymnasium.farama.org/environments/classic_control/mountain_car/) or [Acrobot-v1](https://gymnasium.farama.org/environments/classic_control/acrobot/)." ] }, { "cell_type": "markdown", "metadata": { "id": "gw0D-uwmwpUF" }, "source": [ "Features of this implementation:\n", "- you will learn how to use a `tfq.layers.ControlledPQC` to implement a PQC with data re-uploading, appearing in many applications of QML. This implementation also naturally allows using trainable scaling parameters at the input of the PQC, to increase its expressivity,\n", "- you will learn how to implement observables with trainable weights at the output of a PQC, to allow a flexible range of output values,\n", "- you will learn how a `tf.keras.Model` can be trained with non-trivial ML loss functions, i.e., that are not compatible with `model.compile` and `model.fit`, using a `tf.GradientTape`." ] }, { "cell_type": "markdown", "metadata": { "id": "kLSoeBdTwpUF" }, "source": [ "## Setup" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Install TensorFlow and TensorFlow Quantum:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# In Colab, you will be asked to restart the session after this finishes.\n", "!pip install tensorflow==2.18.1 tensorflow-quantum==0.7.6" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Configure the use of Keras 2:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import os\n", "\n", "# Keras 2 must be selected before importing TensorFlow or TensorFlow Quantum:\n", "os.environ[\"TF_USE_LEGACY_KERAS\"] = \"1\"" ] }, { "cell_type": "markdown", "metadata": { "id": "xLEu0I6qwpUI" }, "source": [ "Install Gymnasium:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "6A2JRKhMwpUJ" }, "outputs": [], "source": [ "!pip install gymnasium[classic-control]==1.2.3" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "F1L8h1YKUvIO" }, "source": [ "Now import TensorFlow, TensorFlow Quantum, and other modules needed:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "RIIYRJ79wpUK" }, "outputs": [], "source": [ "import tensorflow as tf\n", "import tensorflow_quantum as tfq\n", "\n", "import gymnasium as gym\n", "import cirq\n", "import 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", "\n", "tf.get_logger().setLevel('ERROR')" ] }, { "cell_type": "markdown", "metadata": { "id": "jxWGru_NwpUK" }, "source": [ "## 1. Build a PQC with data re-uploading" ] }, { "cell_type": "markdown", "metadata": { "id": "85woLQQswpUL" }, "source": [ "At the core of both RL algorithms you are implementing is a PQC that takes as input the agent's state $s$ in the environment (i.e., a numpy array) and outputs a vector of expectation values. These expectation values are then post-processed, either to produce an agent's policy $\\pi(a|s)$ or approximate Q-values $Q(s,a)$. In this way, the PQCs are playing an analog role to that of deep neural networks in modern deep RL algorithms.\n", "\n", "A popular way to encode an input vector in a PQC is through the use of single-qubit rotations, where rotation angles are controlled by the components of this input vector. In order to get a [highly-expressive model](https://arxiv.org/abs/2008.08605), these single-qubit encodings are not performed only once in the PQC, but in several \"[re-uploadings](https://quantum-journal.org/papers/q-2020-02-06-226/)\", interlayed with variational gates. The layout of such a PQC is depicted below:\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": { "id": "vxw3Rz0awpUL" }, "source": [ "As discussed in [[1]](https://arxiv.org/abs/2103.05577) and [[2]](https://arxiv.org/abs/2103.15084), a way to further enhance the expressivity and trainability of data re-uploading PQCs is to use trainable input-scaling parameters $\\boldsymbol{\\lambda}$ for each encoding gate of the PQC, and trainable observable weights $\\boldsymbol{w}$ at its output." ] }, { "cell_type": "markdown", "metadata": { "id": "rNSjI-OywpUM" }, "source": [ "### 1.1 Cirq circuit for ControlledPQC" ] }, { "cell_type": "markdown", "metadata": { "id": "OCYrUUwswpUM" }, "source": [ "The first step is to implement in Cirq the quantum circuit to be used as the PQC. For this, start by defining basic unitaries to be applied in the circuits, namely an arbitrary single-qubit rotation and an entangling layer of CZ gates:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "id": "X4P5EORYwpUM" }, "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 [\n", " cirq.rx(symbols[0])(qubit),\n", " cirq.ry(symbols[1])(qubit),\n", " cirq.rz(symbols[2])(qubit)\n", " ]\n", "\n", "\n", "def entangling_layer(qubits):\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", " return cz_ops" ] }, { "cell_type": "markdown", "metadata": { "id": "cTgpkm6iwpUM" }, "source": [ "Now, use these functions to generate the Cirq circuit:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "id": "PEicpzq9wpUN" }, "outputs": [], "source": [ "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(\n", " 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(\n", " cirq.rx(inputs[l, i])(q) for i, q in enumerate(qubits))\n", "\n", " # Last varitional layer\n", " circuit += cirq.Circuit(\n", " one_qubit_rotation(q, params[n_layers, i])\n", " for i, q in enumerate(qubits))\n", "\n", " return circuit, list(params.flat), list(inputs.flat)" ] }, { "cell_type": "markdown", "metadata": { "id": "ZL8MvT21wpUN" }, "source": [ "Check that this produces a circuit that is alternating between variational and encoding layers." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 188 }, "id": "M4LFL2bQwpUO", "outputId": "e446c0c0-f844-4d63-9f29-d01f8aeed411" }, "outputs": [ { "data": { "image/svg+xml": [ "(0, 0): (0, 1): (0, 2): Rx(theta0)Rx(theta3)Rx(theta6)Ry(theta1)Ry(theta4)Ry(theta7)Rz(theta2)Rz(theta5)Rz(theta8)Rx(x0_0)Rx(x0_1)Rx(x0_2)Rx(theta9)Rx(theta12)Rx(theta15)Ry(theta10)Ry(theta13)Ry(theta16)Rz(theta11)Rz(theta14)Rz(theta17)" ], "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n_qubits, n_layers = 3, 1\n", "qubits = cirq.GridQubit.rect(1, n_qubits)\n", "circuit, _, _ = generate_circuit(qubits, n_layers)\n", "SVGCircuit(circuit)" ] }, { "cell_type": "markdown", "metadata": { "id": "-RrFUkT3wpUP" }, "source": [ "### 1.2 ReUploadingPQC layer using ControlledPQC\n", "\n", "To construct the re-uploading PQC from the figure above, you can create a custom Keras layer. This layer will manage the trainable parameters (variational angles $\\boldsymbol{\\theta}$ and input-scaling parameters $\\boldsymbol{\\lambda}$) and resolve the input values (input state $s$) into the appropriate symbols in the circuit." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "id": "7XJvWgQ4wpUP" }, "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,\n", " qubits,\n", " n_layers,\n", " observables,\n", " activation=\"linear\",\n", " 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(\n", " qubits, n_layers)\n", "\n", " theta_init = tf.random_uniform_initializer(minval=0.0, maxval=np.pi)\n", " self.theta = tf.Variable(initial_value=theta_init(\n", " shape=(1, len(theta_symbols)), dtype=\"float32\"),\n", " trainable=True,\n", " name=\"thetas\")\n", "\n", " lmbd_init = tf.ones(shape=(self.n_qubits * self.n_layers,))\n", " self.lmbd = tf.Variable(initial_value=lmbd_init,\n", " dtype=\"float32\",\n", " trainable=True,\n", " name=\"lambdas\")\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(\n", " 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": "markdown", "metadata": { "id": "_u3QBKbvwpUP" }, "source": [ "## 2. Policy-gradient RL with PQC policies" ] }, { "cell_type": "markdown", "metadata": { "id": "4deMRl86wpUP" }, "source": [ "In this section, you will implement the policy-gradient algorithm presented in [1]. For this, you will start by constructing, out of the PQC that was just defined, the `softmax-VQC` policy (where VQC stands for variational quantum circuit):\n", "$$ \\pi_\\theta(a|s) = \\frac{e^{\\beta \\langle O_a \\rangle_{s,\\theta}}}{\\sum_{a'} e^{\\beta \\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 output of the PQC, and $\\beta$ is a tunable inverse-temperature parameter. " ] }, { "cell_type": "markdown", "metadata": { "id": "Wb7zQF5AwpUQ" }, "source": [ "You can adopt the same observables used in [1] for CartPole, namely a global $Z_0Z_1Z_2Z_3$ Pauli product acting on all qubits, weighted by an action-specific weight for each action. To implement the weighting of the Pauli product, you can use an extra `tf.keras.layers.Layer` that stores the action-specific weights and applies them multiplicatively on the expectation value $\\langle Z_0Z_1Z_2Z_3 \\rangle_{s,\\theta}$." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "id": "kPLHsGRewpUQ" }, "outputs": [], "source": [ "class Alternating(tf.keras.layers.Layer):\n", "\n", " def __init__(self, output_dim):\n", " super(Alternating, self).__init__()\n", " self.w = tf.Variable(initial_value=tf.constant([[\n", " (-1.)**i for i in range(output_dim)\n", " ]]),\n", " dtype=\"float32\",\n", " trainable=True,\n", " name=\"obs-weights\")\n", "\n", " def call(self, inputs):\n", " return tf.matmul(inputs, self.w)" ] }, { "cell_type": "markdown", "metadata": { "id": "HdyTMNPTwpUQ" }, "source": [ "Prepare the definition of your PQC:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "id": "l3yZCMhywpUQ" }, "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)" ] }, { "cell_type": "markdown", "metadata": { "id": "NMGNUCmOwpUR" }, "source": [ "and its observables:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "id": "qMAc2_--wpUR" }, "outputs": [], "source": [ "ops = [cirq.Z(q) for q in qubits]\n", "observables = [reduce((lambda x, y: x * y), ops)] # Z_0*Z_1*Z_2*Z_3" ] }, { "cell_type": "markdown", "metadata": { "id": "px9D6vE8wpUR" }, "source": [ "With this, define a `tf.keras.Model` that applies, sequentially, the `ReUploadingPQC` layer previously defined, followed by a post-processing layer that computes the weighted observables using `Alternating`, which are then fed into a `tf.keras.layers.Softmax` layer that outputs the `softmax-VQC` policy of the agent." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "id": "-ivAvce6wpUR" }, "outputs": [], "source": [ "def generate_model_policy(qubits, n_layers, n_actions, beta, observables):\n", " \"\"\"Generates a Keras model for a data re-uploading PQC policy.\"\"\"\n", "\n", " input_tensor = tf.keras.Input(shape=(len(qubits),),\n", " dtype=tf.dtypes.float32,\n", " name='input')\n", " re_uploading_pqc = ReUploadingPQC(qubits, n_layers,\n", " observables)([input_tensor])\n", " process = tf.keras.Sequential([\n", " Alternating(n_actions),\n", " tf.keras.layers.Lambda(lambda x: x * beta),\n", " tf.keras.layers.Softmax()\n", " ],\n", " name=\"observables-policy\")\n", " policy = process(re_uploading_pqc)\n", " model = tf.keras.Model(inputs=[input_tensor], outputs=policy)\n", "\n", " return model\n", "\n", "\n", "model = generate_model_policy(qubits, n_layers, n_actions, 1.0, observables)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 232 }, "id": "ANysIOrswpUS", "outputId": "131f0db1-8525-4cfa-a6c5-2b0c8573bdb1" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tf.keras.utils.plot_model(model, show_shapes=True, dpi=70)" ] }, { "cell_type": "markdown", "metadata": { "id": "Ec-s2ECYwpUS" }, "source": [ "You can now train the PQC policy on CartPole-v1, using, e.g., the basic `REINFORCE` algorithm (see Alg. 1 in [1]). Pay attention to the following points:\n", "1. Because scaling parameters, variational angles and observables weights are trained with different learning rates, it is convenient to define 3 separate optimizers with their own learning rates, each updating one of these groups of parameters.\n", "2. The loss function in policy-gradient RL is\n", " $$ \\mathcal{L}(\\theta) = -\\frac{1}{|\\mathcal{B}|}\\sum_{s_0,a_0,r_1,s_1,a_1, \\ldots \\in \\mathcal{B}} \\left(\\sum_{t=0}^{H-1} \\log(\\pi_\\theta(a_t|s_t)) \\sum_{t'=1}^{H-t} \\gamma^{t'} r_{t+t'} \\right)$$\n", "for a batch $\\mathcal{B}$ of episodes $(s_0,a_0,r_1,s_1,a_1, \\ldots)$ of interactions in the environment following the policy $\\pi_\\theta$. This is different from a supervised learning loss with fixed target values that the model should fit, which make it impossible to use a simple function call like `model.fit` to train the policy. Instead, using a `tf.GradientTape` allows to keep track of the computations involving the PQC (i.e., policy sampling) and store their contributions to the loss during the interaction. After running a batch of episodes, you can then apply backpropagation on these computations to get the gradients of the loss with respect to the PQC parameters and use the optimizers to update the policy-model." ] }, { "cell_type": "markdown", "metadata": { "id": "LHS7UlTHwpUS" }, "source": [ "Start by defining a function that gathers episodes of interaction with the environment:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "id": "dYepv83JwpUT" }, "outputs": [], "source": [ "def gather_episodes(state_bounds, n_actions, model, n_episodes, env_name):\n", " \"\"\"Interact with environment in batched fashion.\"\"\"\n", "\n", " trajectories = [defaultdict(list) for _ in range(n_episodes)]\n", " envs = [gym.make(env_name) for _ in range(n_episodes)]\n", "\n", " done = [False for _ in range(n_episodes)]\n", " states = []\n", " for i, env in enumerate(envs):\n", " state, _ = env.reset()\n", " states.append(state)\n", "\n", " while not all(done):\n", " unfinished_ids = [i for i in range(n_episodes) if not done[i]]\n", " normalized_states = [\n", " s / state_bounds for i, s in enumerate(states) if not done[i]\n", " ]\n", "\n", " for i, state in zip(unfinished_ids, normalized_states):\n", " trajectories[i]['states'].append(state)\n", "\n", " # Compute policy for all unfinished envs in parallel\n", " states = tf.convert_to_tensor(normalized_states)\n", " action_probs = model([states])\n", "\n", " # Store action and transition all environments to the next state\n", " states = [None for i in range(n_episodes)]\n", " for i, policy in zip(unfinished_ids, action_probs.numpy()):\n", " action = np.random.choice(n_actions, p=policy)\n", " states[i], reward, terminated, truncated, _ = envs[i].step(action)\n", " done[i] = terminated or truncated\n", " trajectories[i]['actions'].append(action)\n", " trajectories[i]['rewards'].append(reward)\n", "\n", " return trajectories" ] }, { "cell_type": "markdown", "metadata": { "id": "TJRGD1g1wpUT" }, "source": [ "and a function that computes discounted returns $\\sum_{t'=1}^{H-t} \\gamma^{t'} r_{t+t'}$ out of the rewards $r_t$ collected in an episode:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "id": "KGDLrNN1wpUT" }, "outputs": [], "source": [ "def compute_returns(rewards_history, gamma):\n", " \"\"\"Compute discounted returns with discount factor `gamma`.\"\"\"\n", " returns = []\n", " discounted_sum = 0\n", " for r in rewards_history[::-1]:\n", " discounted_sum = r + gamma * discounted_sum\n", " returns.insert(0, discounted_sum)\n", "\n", " # Normalize them for faster and more stable learning\n", " returns = np.array(returns)\n", " returns = (returns - np.mean(returns)) / (np.std(returns) + 1e-8)\n", " returns = returns.tolist()\n", "\n", " return returns" ] }, { "cell_type": "markdown", "metadata": { "id": "xkuUMdskwpUT" }, "source": [ "Define the hyperparameters:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "id": "QUuSU1LRwpUU" }, "outputs": [], "source": [ "state_bounds = np.array([2.4, 2.5, 0.21, 2.5])\n", "gamma = 1\n", "batch_size = 10\n", "n_episodes = 1000" ] }, { "cell_type": "markdown", "metadata": { "id": "PM8uFSLMwpUU" }, "source": [ "Prepare the optimizers:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "id": "2fxGvCKpwpUU" }, "outputs": [], "source": [ "optimizer_in = tf.keras.optimizers.Adam(learning_rate=0.1, amsgrad=True)\n", "optimizer_var = tf.keras.optimizers.Adam(learning_rate=0.01, 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": "JbVHz19-wpUU" }, "source": [ "Implement a function that updates the policy using states, actions and returns:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "id": "zLfbu8Q2wpUV" }, "outputs": [], "source": [ "@tf.function\n", "def reinforce_update(states, actions, returns, model):\n", " states = tf.convert_to_tensor(states)\n", " actions = tf.convert_to_tensor(actions)\n", " returns = tf.convert_to_tensor(returns)\n", "\n", " with tf.GradientTape() as tape:\n", " tape.watch(model.trainable_variables)\n", " logits = model(states)\n", " p_actions = tf.gather_nd(logits, actions)\n", " log_probs = tf.math.log(p_actions)\n", " loss = tf.math.reduce_sum(-log_probs * returns) / batch_size\n", " grads = tape.gradient(loss, model.trainable_variables)\n", " for optimizer, w in zip([optimizer_in, optimizer_var, optimizer_out],\n", " [w_in, w_var, w_out]):\n", " optimizer.apply_gradients([(grads[w], model.trainable_variables[w])])" ] }, { "cell_type": "markdown", "metadata": { "id": "rrPlDlqLwpUV" }, "source": [ "Now implement the main training loop of the agent." ] }, { "cell_type": "markdown", "metadata": { "id": "95Foz1XewpUV" }, "source": [ "Note: This agent may need to simulate several million quantum circuits and can take as much as ~20 minutes to finish training." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cYSDSNGlwpUW", "outputId": "ae603811-b930-4484-a002-d26c4673fa06" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Finished episode 10 Average rewards: 21.4\n", "Finished episode 20 Average rewards: 27.1\n", "Finished episode 30 Average rewards: 23.3\n", "Finished episode 40 Average rewards: 18.0\n", "Finished episode 50 Average rewards: 21.6\n", "Finished episode 60 Average rewards: 31.9\n", "Finished episode 70 Average rewards: 35.4\n", "Finished episode 80 Average rewards: 53.1\n", "Finished episode 90 Average rewards: 38.9\n", "Finished episode 100 Average rewards: 49.9\n", "Finished episode 110 Average rewards: 34.4\n", "Finished episode 120 Average rewards: 55.1\n", "Finished episode 130 Average rewards: 112.3\n", "Finished episode 140 Average rewards: 95.2\n", "Finished episode 150 Average rewards: 120.5\n", "Finished episode 160 Average rewards: 132.5\n", "Finished episode 170 Average rewards: 102.0\n", "Finished episode 180 Average rewards: 149.9\n", "Finished episode 190 Average rewards: 119.4\n", "Finished episode 200 Average rewards: 149.2\n", "Finished episode 210 Average rewards: 153.8\n", "Finished episode 220 Average rewards: 185.0\n", "Finished episode 230 Average rewards: 259.9\n", "Finished episode 240 Average rewards: 368.8\n", "Finished episode 250 Average rewards: 287.4\n", "Finished episode 260 Average rewards: 277.3\n", "Finished episode 270 Average rewards: 345.4\n", "Finished episode 280 Average rewards: 452.9\n", "Finished episode 290 Average rewards: 459.7\n", "Finished episode 300 Average rewards: 435.9\n", "Finished episode 310 Average rewards: 442.5\n", "Finished episode 320 Average rewards: 424.1\n", "Finished episode 330 Average rewards: 497.6\n", "Finished episode 340 Average rewards: 465.3\n", "Finished episode 350 Average rewards: 484.5\n", "Finished episode 360 Average rewards: 452.0\n", "Finished episode 370 Average rewards: 483.2\n", "Finished episode 380 Average rewards: 484.7\n", "Finished episode 390 Average rewards: 464.6\n", "Finished episode 400 Average rewards: 422.6\n", "Finished episode 410 Average rewards: 455.9\n", "Finished episode 420 Average rewards: 471.5\n", "Finished episode 430 Average rewards: 475.0\n", "Finished episode 440 Average rewards: 476.1\n", "Finished episode 450 Average rewards: 475.7\n", "Finished episode 460 Average rewards: 498.8\n", "Finished episode 470 Average rewards: 500.0\n" ] } ], "source": [ "env_name = \"CartPole-v1\"\n", "\n", "# Start training the agent\n", "episode_reward_history = []\n", "for batch in range(n_episodes // batch_size):\n", " # Gather episodes\n", " episodes = gather_episodes(state_bounds, n_actions, model, batch_size,\n", " env_name)\n", "\n", " # Group states, actions and returns in numpy arrays\n", " states = np.concatenate([ep['states'] for ep in episodes])\n", " actions = np.concatenate([ep['actions'] for ep in episodes])\n", " rewards = [ep['rewards'] for ep in episodes]\n", " returns = np.concatenate(\n", " [compute_returns(ep_rwds, gamma) for ep_rwds in rewards])\n", " returns = np.array(returns, dtype=np.float32)\n", "\n", " id_action_pairs = np.array([[i, a] for i, a in enumerate(actions)])\n", "\n", " # Update model parameters.\n", " reinforce_update(states, id_action_pairs, returns, model)\n", "\n", " # Store collected rewards\n", " for ep_rwds in rewards:\n", " episode_reward_history.append(np.sum(ep_rwds))\n", "\n", " avg_rewards = np.mean(episode_reward_history[-10:])\n", "\n", " print('Finished episode', (batch + 1) * batch_size, 'Average rewards: ',\n", " avg_rewards)\n", "\n", " if avg_rewards >= 500.0:\n", " break" ] }, { "cell_type": "markdown", "metadata": { "id": "8E7Be2SqwpUW" }, "source": [ "Plot the learning history of the agent:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 334 }, "id": "51RzNBZqwpUX", "outputId": "36b2eae1-7113-4d21-f39e-7d1bab291401", "scrolled": true }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "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": "Qfdf4DBkwpUX" }, "source": [ "Congratulations, you have trained a quantum policy gradient model on Cartpole! The plot above shows the rewards collected by the agent per episode throughout its interaction with the environment. You should see that after a few hundred episodes, the performance of the agent gets close to optimal, i.e., 500 rewards per episode. " ] }, { "cell_type": "markdown", "metadata": { "id": "YtaBfoERwpUX" }, "source": [ "You can now visualize the performance of your agent using `env.render()` in a sample episode (uncomment/run the following cell only if your notebook has access to a display):" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "-VpROTJ1wpUX" }, "outputs": [], "source": [ "# from PIL import Image\n", "\n", "# env = gym.make('CartPole-v1', render_mode=\"rgb_array\")\n", "# state, _ = env.reset()\n", "# frames = []\n", "# for t in range(500):\n", "# im = Image.fromarray(env.render())\n", "# frames.append(im)\n", "# policy = model([tf.convert_to_tensor([state/state_bounds])])\n", "# action = np.random.choice(n_actions, p=policy.numpy()[0])\n", "# state, _, terminated, truncated, _ = env.step(action)\n", "# done = terminated or truncated\n", "# if done:\n", "# break\n", "# env.close()\n", "# frames[1].save('./images/gym_CartPole.gif',\n", "# save_all=True, append_images=frames[2:], optimize=False, duration=40, loop=0)" ] }, { "cell_type": "markdown", "metadata": { "id": "i0iA0nubwpUX" }, "source": [ "" ] }, { "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 [2]. 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 [2] 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": 33, "metadata": { "id": "MX5l96qywpUY" }, "outputs": [], "source": [ "class Rescaling(tf.keras.layers.Layer):\n", "\n", " def __init__(self, input_dim):\n", " super(Rescaling, self).__init__()\n", " self.input_dim = input_dim\n", " self.w = tf.Variable(initial_value=tf.ones(shape=(1, input_dim)),\n", " dtype=\"float32\",\n", " trainable=True,\n", " name=\"obs-weights\")\n", "\n", " def call(self, inputs):\n", " return tf.math.multiply((inputs + 1) / 2,\n", " tf.repeat(self.w,\n", " repeats=tf.shape(inputs)[0],\n", " axis=0))" ] }, { "cell_type": "markdown", "metadata": { "id": "oesnEQa7wpUY" }, "source": [ "Prepare the definition of your PQC and its observables:" ] }, { "cell_type": "code", "execution_count": 34, "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],\n", " 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": 35, "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),),\n", " dtype=tf.dtypes.float32,\n", " name='input')\n", " re_uploading_pqc = ReUploadingPQC(qubits,\n", " n_layers,\n", " observables,\n", " activation='tanh')([input_tensor])\n", " process = tf.keras.Sequential([Rescaling(len(observables))],\n", " 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", "\n", "model = generate_model_Qlearning(qubits, n_layers, n_actions, observables,\n", " False)\n", "model_target = generate_model_Qlearning(qubits, n_layers, n_actions,\n", " observables, True)\n", "\n", "model_target.set_weights(model.get_weights())" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 232 }, "id": "57TxgIN5wpUZ", "outputId": "da6a3aee-1722-40b3-fae5-2972d8c2ed88" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tf.keras.utils.plot_model(model, show_shapes=True, dpi=70)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 232 }, "id": "jHp42R4twpUa", "outputId": "69a20e50-fde4-4634-897b-01edaeab420a" }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "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": 38, "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, terminated, truncated, _ = env.step(action)\n", " done = terminated or truncated\n", "\n", " interaction = {\n", " 'state': state_array,\n", " 'action': action,\n", " 'next_state': next_state.copy(),\n", " 'reward': reward,\n", " 'done': np.float32(done)\n", " }\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": 39, "metadata": { "id": "RR2DjesVwpUb" }, "outputs": [], "source": [ "@tf.function\n", "def Q_learning_update(states, actions, rewards, next_states, done, model, gamma,\n", " 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],\n", " [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": 40, "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": 41, "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": null, "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 28.8\n", "Episode 20/2000, average last 10 rewards 22.2\n", "Episode 30/2000, average last 10 rewards 24.3\n", "Episode 40/2000, average last 10 rewards 30.5\n", "Episode 50/2000, average last 10 rewards 27.6\n", "Episode 60/2000, average last 10 rewards 28.2\n", "Episode 70/2000, average last 10 rewards 31.7\n", "Episode 80/2000, average last 10 rewards 23.7\n", "Episode 90/2000, average last 10 rewards 29.1\n", "Episode 100/2000, average last 10 rewards 26.3\n", "Episode 110/2000, average last 10 rewards 23.5\n", "Episode 120/2000, average last 10 rewards 22.1\n", "Episode 130/2000, average last 10 rewards 26.9\n", "Episode 140/2000, average last 10 rewards 25.5\n", "Episode 150/2000, average last 10 rewards 20.9\n", "Episode 160/2000, average last 10 rewards 27.0\n", "Episode 170/2000, average last 10 rewards 27.8\n", "Episode 180/2000, average last 10 rewards 27.2\n", "Episode 190/2000, average last 10 rewards 28.9\n", "Episode 200/2000, average last 10 rewards 27.4\n", "Episode 210/2000, average last 10 rewards 31.4\n", "Episode 220/2000, average last 10 rewards 31.2\n", "Episode 230/2000, average last 10 rewards 25.9\n", "Episode 240/2000, average last 10 rewards 29.7\n", "Episode 250/2000, average last 10 rewards 34.1\n", "Episode 260/2000, average last 10 rewards 23.9\n", "Episode 270/2000, average last 10 rewards 31.2\n", "Episode 280/2000, average last 10 rewards 35.9\n", "Episode 290/2000, average last 10 rewards 33.1\n", "Episode 300/2000, average last 10 rewards 31.0\n", "Episode 310/2000, average last 10 rewards 34.3\n", "Episode 320/2000, average last 10 rewards 28.2\n", "Episode 330/2000, average last 10 rewards 35.0\n", "Episode 340/2000, average last 10 rewards 35.0\n", "Episode 350/2000, average last 10 rewards 33.9\n", "Episode 360/2000, average last 10 rewards 35.1\n", "Episode 370/2000, average last 10 rewards 28.5\n", "Episode 380/2000, average last 10 rewards 24.5\n", "Episode 390/2000, average last 10 rewards 30.3\n", "Episode 400/2000, average last 10 rewards 34.2\n", "Episode 410/2000, average last 10 rewards 33.5\n", "Episode 420/2000, average last 10 rewards 32.1\n", "Episode 430/2000, average last 10 rewards 25.6\n", "Episode 440/2000, average last 10 rewards 29.1\n", "Episode 450/2000, average last 10 rewards 30.8\n", "Episode 460/2000, average last 10 rewards 47.5\n", "Episode 470/2000, average last 10 rewards 64.9\n", "Episode 480/2000, average last 10 rewards 68.2\n", "Episode 490/2000, average last 10 rewards 76.2\n", "Episode 500/2000, average last 10 rewards 91.0\n", "Episode 510/2000, average last 10 rewards 93.5\n", "Episode 520/2000, average last 10 rewards 225.9\n", "Episode 530/2000, average last 10 rewards 288.2\n", "Episode 540/2000, average last 10 rewards 358.4\n", "Episode 550/2000, average last 10 rewards 437.1\n", "Episode 560/2000, average last 10 rewards 401.4\n", "Episode 570/2000, average last 10 rewards 430.1\n", "Episode 580/2000, average last 10 rewards 467.6\n", "Episode 590/2000, average last 10 rewards 487.6\n", "Episode 600/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(\n", " 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],\n", " dtype=np.float32),\n", " np.asarray([x['next_state'] for x in training_batch]),\n", " np.asarray([x['done'] for x in training_batch],\n", " dtype=np.float32), 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(\n", " f\"Episode {episode + 1}/{n_episodes}, average last 10 rewards {avg_rewards}\"\n", " )\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": 43, "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": [ "
" ] }, "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." ] }, { "cell_type": "markdown", "metadata": { "id": "X8X49f8owpUe" }, "source": [ "## 4. Exercise\n", "\n", "Now that you have trained two different types of models, try experimenting with different environments (and different numbers of qubits and layers). You could also try combining the PQC models of the last two sections into an [actor-critic agent](https://lilianweng.github.io/lil-log/2018/04/08/policy-gradient-algorithms.html#actor-critic)." ] } ], "metadata": { "colab": { "collapsed_sections": [ "jxWGru_NwpUK", "_u3QBKbvwpUP", "X8X49f8owpUe" ], "name": "quantum_reinforcement_learning.ipynb", "provenance": [] }, "kernelspec": { "display_name": "venv", "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.12.3" } }, "nbformat": 4, "nbformat_minor": 4 }