{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# qGANs for Loading Random Distributions\n", "\n", "Given $k$-dimensional data samples, we employ a quantum Generative Adversarial Network (qGAN) to learn the data's underlying random distribution and to load it directly into a quantum state:\n", "\n", "$$\\big| g_{\\theta}\\rangle = \\sum_{j=0}^{2^n-1} \\sqrt{p_{\\theta}^{j}}\\big| j \\rangle$$\n", "\n", "where $p_{\\theta}^{j}$ describe the occurrence probabilities of the basis states $\\big| j\\rangle$. \n", "\n", "The aim of the qGAN training is to generate a state $\\big| g_{\\theta}\\rangle$ where $p_{\\theta}^{j}$, for $j\\in \\left\\{0, \\ldots, {2^n-1} \\right\\}$, describe a probability distribution that is close to the distribution underlying the training data $X=\\left\\{x^0, \\ldots, x^{k-1} \\right\\}$.\n", "\n", "For further details please refer to [Quantum Generative Adversarial Networks for Learning and Loading Random Distributions](https://arxiv.org/abs/1904.00043) _Zoufal, Lucchi, Woerner_ \$2019\$.\n", "\n", "For an example of how to use a trained qGAN in an application, the pricing of financial derivatives, please see the\n", "[Option Pricing with qGANs](https://github.com/Qiskit/qiskit-finance/tree/main/docs/tutorials/10_qgan_option_pricing.ipynb) tutorial." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "seed = 71\n", "np.random.seed = seed\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "%matplotlib inline\n", "\n", "from qiskit import QuantumRegister, QuantumCircuit, BasicAer\n", "from qiskit.circuit.library import TwoLocal\n", "\n", "from qiskit.utils import QuantumInstance, algorithm_globals\n", "from qiskit_machine_learning.algorithms import NumPyDiscriminator, QGAN\n", "\n", "algorithm_globals.random_seed = seed" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Load the Training Data\n", "\n", "First, we need to load the $k$-dimensional training data samples (here k=1).\n", "\n", "Next, the data resolution is set, i.e. the min/max data values and the number of qubits used to represent each data dimension." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Number training data samples\n", "N = 1000\n", "\n", "# Load data samples from log-normal distribution with mean=1 and standard deviation=1\n", "mu = 1\n", "sigma = 1\n", "real_data = np.random.lognormal(mean=mu, sigma=sigma, size=N)\n", "\n", "# Set the data resolution\n", "# Set upper and lower data values as list of k min/max data values [[min_0,max_0],...,[min_k-1,max_k-1]]\n", "bounds = np.array([0.0, 3.0])\n", "# Set number of qubits per data dimension as list of k qubit values[#q_0,...,#q_k-1]\n", "num_qubits = [2]\n", "k = len(num_qubits)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Initialize the qGAN\n", "\n", "The qGAN consists of a quantum generator $G_{\\theta}$, i.e., an ansatz, and a classical discriminator $D_{\\phi}$, a neural network.\n", "\n", "To implement the quantum generator, we choose a depth-$1$ ansatz that implements $R_Y$ rotations and $CZ$ gates which takes a uniform distribution as an input state. Notably, for $k>1$ the generator's parameters must be chosen carefully. For example, the circuit depth should be $>1$ because higher circuit depths enable the representation of more complex structures.\n", "\n", "The classical discriminator used here is based on a neural network implementation using NumPy. There is also a discriminator based on PyTorch which is not installed by default when installing Qiskit - see [Optional Install](https://github.com/Qiskit/qiskit-machine-learning#optional-installs) for more information.\n", "\n", "Here, both networks are updated with the ADAM optimization algorithm (ADAM is qGAN optimizer default)." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Set number of training epochs\n", "# Note: The algorithm's runtime can be shortened by reducing the number of training epochs.\n", "num_epochs = 10\n", "# Batch size\n", "batch_size = 100\n", "\n", "# Initialize qGAN\n", "qgan = QGAN(real_data, bounds, num_qubits, batch_size, num_epochs, snapshot_dir=None)\n", "qgan.seed = 1\n", "# Set quantum instance to run the quantum generator\n", "quantum_instance = QuantumInstance(\n", " backend=BasicAer.get_backend(\"statevector_simulator\"), seed_transpiler=seed, seed_simulator=seed\n", ")\n", "\n", "# Set entangler map\n", "entangler_map = [[0, 1]]\n", "\n", "\n", "# Set an initial state for the generator circuit as a uniform distribution\n", "# This corresponds to applying Hadamard gates on all qubits\n", "init_dist = QuantumCircuit(sum(num_qubits))\n", "init_dist.h(init_dist.qubits)\n", "\n", "# Set the ansatz circuit\n", "ansatz = TwoLocal(int(np.sum(num_qubits)), \"ry\", \"cz\", entanglement=entangler_map, reps=1)\n", "\n", "# Set generator's initial parameters - in order to reduce the training time and hence the\n", "# total running time for this notebook\n", "init_params = [3.0, 1.0, 0.6, 1.6]\n", "\n", "# You can increase the number of training epochs and use random initial parameters.\n", "# init_params = np.random.rand(ansatz.num_parameters_settable) * 2 * np.pi\n", "\n", "# Set generator circuit by adding the initial distribution infront of the ansatz\n", "g_circuit = ansatz.compose(init_dist, front=True)\n", "\n", "# Set quantum generator\n", "qgan.set_generator(generator_circuit=g_circuit, generator_init_params=init_params)\n", "# The parameters have an order issue that following is a temp. workaround\n", "qgan._generator._free_parameters = sorted(g_circuit.parameters, key=lambda p: p.name)\n", "# Set classical discriminator neural network\n", "discriminator = NumPyDiscriminator(len(num_qubits))\n", "qgan.set_discriminator(discriminator)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Run the qGAN Training\n", "\n", "During the training the discriminator's and the generator's parameters are updated alternately w.r.t the following loss functions:\n", "$$L_G\\left(\\phi, \\theta\\right) = -\\frac{1}{m}\\sum\\limits_{l=1}^{m}\\left[\\log\\left(D_{\\phi}\\left(g^{l}\\right)\\right)\\right]$$\n", "and\n", "$$L_D\\left(\\phi, \\theta\\right) =\n", "\t\\frac{1}{m}\\sum\\limits_{l=1}^{m}\\left[\\log D_{\\phi}\\left(x^{l}\\right) + \\log\\left(1-D_{\\phi}\\left(g^{l}\\right)\\right)\\right],$$\n", "with $m$ denoting the batch size and $g^l$ describing the data samples generated by the quantum generator.\n", "\n", "Please note that the training, for the purpose of this notebook, has been kept briefer by the selection of a known initial point (init_params). Without such prior knowledge be aware training may take some while." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Run qGAN\n", "result = qgan.run(quantum_instance)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training results:\n", " params_d : [ 0.03697158 0.61015372 -0.48103428 ... -0.1661673 -0.20186384\n", " -0.08584337]\n", " params_g : [2.95229918 0.9522102 0.55218478 1.64793094]\n", " loss_d : 0.6925\n", " loss_g : [0.7246]\n", " rel_entr : 0.107\n" ] } ], "source": [ "print(\"Training results:\")\n", "for key, value in result.items():\n", " print(f\" {key} : {value}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Training Progress & Outcome\n", "\n", "Now, we plot the evolution of the generator's and the discriminator's loss functions during the training, as well as the progress in the relative entropy between the trained and the target distribution.\n", "\n", "Finally, we also compare the cumulative distribution function (CDF) of the trained distribution to the CDF of the target distribution." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "