--- a
+++ b/Code/All Qiskit, PennyLane QML Nov 23/22a Quantum GANs 600Iter kkawchak.ipynb
@@ -0,0 +1,1001 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 16,
+      "metadata": {
+        "id": "Adv9qCFis2V1",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "outputId": "a4686dfd-ea8d-4e6e-fb40-55ed618a2282"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Time in seconds since beginning of run: 1700536349.8000453\n",
+            "Tue Nov 21 03:12:29 2023\n"
+          ]
+        }
+      ],
+      "source": [
+        "# This cell is added by sphinx-gallery\n",
+        "# It can be customized to whatever you like\n",
+        "%matplotlib inline\n",
+        "# !pip install pennylane\n",
+        "# from google.colab import drive\n",
+        "# drive.mount('/content/drive')\n",
+        "import time\n",
+        "seconds = time.time()\n",
+        "print(\"Time in seconds since beginning of run:\", seconds)\n",
+        "local_time = time.ctime(seconds)\n",
+        "print(local_time)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "UK7teNKZs2V2"
+      },
+      "source": [
+        "Quantum GANs {#quantum_gans}\n",
+        "============\n",
+        "\n",
+        "::: {.meta}\n",
+        ":property=\\\"og:description\\\": Explore quantum GANs to generate\n",
+        "hand-written digits of zero :property=\\\"og:image\\\":\n",
+        "<https://pennylane.ai/qml/_images/patch.jpeg>\n",
+        ":::\n",
+        "\n",
+        "::: {.related}\n",
+        "tutorial\\_QGAN Quantum generative adversarial networks with Cirq +\n",
+        "TensorFlow\n",
+        ":::\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "xjulm5j1s2V3"
+      },
+      "source": [
+        "*Author: James Ellis --- Posted: 01 February 2022. Last updated: 27\n",
+        "January 2022.*\n",
+        "\n",
+        "In this tutorial, we will explore quantum GANs to generate hand-written\n",
+        "digits of zero. We will first cover the theory of the classical case,\n",
+        "then extend to a quantum method recently proposed in the literature. If\n",
+        "you have no experience with GANs, particularly in PyTorch, you might\n",
+        "find [PyTorch\\'s\n",
+        "tutorial](https://pytorch.org/tutorials/beginner/dcgan_faces_tutorial.html)\n",
+        "useful since it serves as the foundation for what is to follow.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "lEfsJh_fs2V3"
+      },
+      "source": [
+        "Generative Adversarial Networks (GANs)\n",
+        "======================================\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "EByLMGeNs2V3"
+      },
+      "source": [
+        "The goal of generative adversarial networks (GANs) is to generate data\n",
+        "that resembles the original data used in training. To achieve this, we\n",
+        "train two neural networks simulatenously: a generator and a\n",
+        "discriminator. The job of the generator is to create fake data which\n",
+        "imitates the real training dataset. On the otherhand, the discriminator\n",
+        "acts like a detective trying to discern real from fake data. During the\n",
+        "training process, both players iteratively improve with one another. By\n",
+        "the end, the generator should hopefully generate new data very similar\n",
+        "to the training dataset.\n",
+        "\n",
+        "Specifically, the training dataset represents samples drawn from some\n",
+        "unknown data distribution $P_{data}$, and the generator has the job of\n",
+        "trying to capture this distribution. The generator, $G$, starts from\n",
+        "some initial latent distribution, $P_z$, and maps it to $P_g = G(P_z)$.\n",
+        "The best solution would be for $P_g = P_{data}$. However, this point is\n",
+        "rarely achieved in practice apart from in the most simple tasks.\n",
+        "\n",
+        "Both the discriminator, $D$, and generator, $G$, play in a 2-player\n",
+        "minimax game. The discriminator tries to maximise the probability of\n",
+        "discerning real from fake data, while the generator tries to minimise\n",
+        "the same probability. The value function for the game is summarised by,\n",
+        "\n",
+        "$$\\begin{aligned}\n",
+        "\\begin{align}\n",
+        "\\min_G \\max_D V(D,G) &= \\mathbb{E}_{\\boldsymbol{x}\\sim p_{data}}[\\log D(\\boldsymbol{x})] \\\\\n",
+        "    & ~~ + \\mathbb{E}_{\\boldsymbol{z}\\sim p_{\\boldsymbol{z}}}[\\log(1 - D(G(\\boldsymbol{z}))]\n",
+        "\\end{align}\n",
+        "\\end{aligned}$$\n",
+        "\n",
+        "-   $\\boldsymbol{x}$: real data sample\n",
+        "-   $\\boldsymbol{z}$: latent vector\n",
+        "-   $D(\\boldsymbol{x})$: probability of the discriminator classifying\n",
+        "    real data as real\n",
+        "-   $G(\\boldsymbol{z})$: fake data\n",
+        "-   $D(G(\\boldsymbol{z}))$: probability of discriminator classifying\n",
+        "    fake data as real\n",
+        "\n",
+        "In practice, the two networks are trained iteratively, each with a\n",
+        "separate loss function to be minimised,\n",
+        "\n",
+        "$$L_D = -[y \\cdot \\log(D(x)) + (1-y)\\cdot \\log(1-D(G(z)))]$$\n",
+        "\n",
+        "$$L_G = [(1-y) \\cdot \\log(1-D(G(z)))]$$\n",
+        "\n",
+        "where $y$ is a binary label for real ($y=1$) or fake ($y=0$) data. In\n",
+        "practice, generator training is shown to be more stable when made to\n",
+        "maximise $\\log(D(G(z)))$ instead of minimising $\\log(1-D(G(z)))$. Hence,\n",
+        "the generator loss function to be minimised becomes,\n",
+        "\n",
+        "$$L_G = -[(1-y) \\cdot \\log(D(G(z)))]$$\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "EZP6T-7Is2V3"
+      },
+      "source": [
+        "Quantum GANs: The Patch Method\n",
+        "==============================\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PonC35zos2V3"
+      },
+      "source": [
+        "In this tutorial, we re-create one of the quantum GAN methods presented\n",
+        "by Huang et al.: the patch method. This method uses several quantum\n",
+        "generators, with each sub-generator, $G^{(i)}$, responsible for\n",
+        "constructing a small patch of the final image. The final image is\n",
+        "contructed by concatenting all of the patches together as shown below.\n",
+        "\n",
+        "![](../demonstrations/quantum_gans/patch.jpeg){.align-center\n",
+        "width=\"90.0%\"}\n",
+        "\n",
+        "The main advantage of this method is that it is particulary suited to\n",
+        "situations where the number of available qubits are limited. The same\n",
+        "quantum device can be used for each sub-generator in an iterative\n",
+        "fashion, or execution of the generators can be parallelised across\n",
+        "multiple devices.\n",
+        "\n",
+        "::: {.note}\n",
+        "::: {.title}\n",
+        "Note\n",
+        ":::\n",
+        "\n",
+        "In this tutorial, parenthesised superscripts are used to denote\n",
+        "individual objects as part of a collection.\n",
+        ":::\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FoPuIvwJs2V3"
+      },
+      "source": [
+        "Module Imports\n",
+        "==============\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 17,
+      "metadata": {
+        "id": "3HyrRTKws2V3"
+      },
+      "outputs": [],
+      "source": [
+        "# Library imports\n",
+        "import math\n",
+        "import random\n",
+        "import numpy as np\n",
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import matplotlib.gridspec as gridspec\n",
+        "import pennylane as qml\n",
+        "\n",
+        "# Pytorch imports\n",
+        "import torch\n",
+        "import torch.nn as nn\n",
+        "import torch.optim as optim\n",
+        "import torchvision\n",
+        "import torchvision.transforms as transforms\n",
+        "from torch.utils.data import Dataset, DataLoader\n",
+        "\n",
+        "# Set the random seed for reproducibility\n",
+        "seed = 42\n",
+        "torch.manual_seed(seed)\n",
+        "np.random.seed(seed)\n",
+        "random.seed(seed)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "PlFxROwFs2V3"
+      },
+      "source": [
+        "Data\n",
+        "====\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "0Xc1K-WFs2V4"
+      },
+      "source": [
+        "As mentioned in the introduction, we will use a [small\n",
+        "dataset](https://archive.ics.uci.edu/ml/datasets/optical+recognition+of+handwritten+digits)\n",
+        "of handwritten zeros. First, we need to create a custom dataloader for\n",
+        "this dataset.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 18,
+      "metadata": {
+        "id": "bS-UnbQ8s2V4"
+      },
+      "outputs": [],
+      "source": [
+        "class DigitsDataset(Dataset):\n",
+        "    \"\"\"Pytorch dataloader for the Optical Recognition of Handwritten Digits Data Set\"\"\"\n",
+        "\n",
+        "    def __init__(self, csv_file, label=0, transform=None):\n",
+        "        \"\"\"\n",
+        "        Args:\n",
+        "            csv_file (string): Path to the csv file with annotations.\n",
+        "            root_dir (string): Directory with all the images.\n",
+        "            transform (callable, optional): Optional transform to be applied\n",
+        "                on a sample.\n",
+        "        \"\"\"\n",
+        "        self.csv_file = csv_file\n",
+        "        self.transform = transform\n",
+        "        self.df = self.filter_by_label(label)\n",
+        "\n",
+        "    def filter_by_label(self, label):\n",
+        "        # Use pandas to return a dataframe of only zeros\n",
+        "        df = pd.read_csv(self.csv_file)\n",
+        "        df = df.loc[df.iloc[:, -1] == label]\n",
+        "        return df\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.df)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        if torch.is_tensor(idx):\n",
+        "            idx = idx.tolist()\n",
+        "\n",
+        "        image = self.df.iloc[idx, :-1] / 16\n",
+        "        image = np.array(image)\n",
+        "        image = image.astype(np.float32).reshape(8, 8)\n",
+        "\n",
+        "        if self.transform:\n",
+        "            image = self.transform(image)\n",
+        "\n",
+        "        # Return image and label\n",
+        "        return image, 0"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "za7LyZnNs2V4"
+      },
+      "source": [
+        "Next we define some variables and create the dataloader instance.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 19,
+      "metadata": {
+        "id": "FejShZNxs2V4"
+      },
+      "outputs": [],
+      "source": [
+        "image_size = 8  # Height / width of the square images\n",
+        "batch_size = 1\n",
+        "\n",
+        "transform = transforms.Compose([transforms.ToTensor()])\n",
+        "dataset = DigitsDataset(csv_file=\"/content/drive/MyDrive/Colab Notebooks/data/optdigits.tra\", transform=transform)\n",
+        "dataloader = torch.utils.data.DataLoader(\n",
+        "    dataset, batch_size=batch_size, shuffle=True, drop_last=True\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "FEFii_G2s2V4"
+      },
+      "source": [
+        "Let\\'s visualize some of the data.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 20,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 102
+        },
+        "id": "dzGFZQyRs2V4",
+        "outputId": "4a63c5fb-665a-4fa8-b847-426f7f65814e"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 800x200 with 8 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "plt.figure(figsize=(8,2))\n",
+        "\n",
+        "for i in range(8):\n",
+        "    image = dataset[i][0].reshape(image_size,image_size)\n",
+        "    plt.subplot(1,8,i+1)\n",
+        "    plt.axis('off')\n",
+        "    plt.imshow(image.numpy(), cmap='gray')\n",
+        "\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "-NemlIWxs2V4"
+      },
+      "source": [
+        "Implementing the Discriminator\n",
+        "==============================\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "IOcvPprks2V4"
+      },
+      "source": [
+        "For the discriminator, we use a fully connected neural network with two\n",
+        "hidden layers. A single output is sufficient to represent the\n",
+        "probability of an input being classified as real.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 21,
+      "metadata": {
+        "id": "hPJvAU4Ts2V4"
+      },
+      "outputs": [],
+      "source": [
+        "class Discriminator(nn.Module):\n",
+        "    \"\"\"Fully connected classical discriminator\"\"\"\n",
+        "\n",
+        "    def __init__(self):\n",
+        "        super().__init__()\n",
+        "\n",
+        "        self.model = nn.Sequential(\n",
+        "            # Inputs to first hidden layer (num_input_features -> 64)\n",
+        "            nn.Linear(image_size * image_size, 64),\n",
+        "            nn.ReLU(),\n",
+        "            # First hidden layer (64 -> 16)\n",
+        "            nn.Linear(64, 16),\n",
+        "            nn.ReLU(),\n",
+        "            # Second hidden layer (16 -> output)\n",
+        "            nn.Linear(16, 1),\n",
+        "            nn.Sigmoid(),\n",
+        "        )\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        return self.model(x)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "1s1-1Hcus2V4"
+      },
+      "source": [
+        "Implementing the Generator\n",
+        "==========================\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "V1rbipYps2V4"
+      },
+      "source": [
+        "Each sub-generator, $G^{(i)}$, shares the same circuit architecture as\n",
+        "shown below. The overall quantum generator consists of $N_G$\n",
+        "sub-generators, each consisting of $N$ qubits. The process from latent\n",
+        "vector input to image output can be split into four distinct sections:\n",
+        "state embedding, parameterisation, non-linear transformation, and\n",
+        "post-processing. Each of the following sections below refer to a single\n",
+        "iteration of the training process to simplify the discussion.\n",
+        "\n",
+        "![](../demonstrations/quantum_gans/qcircuit.jpeg){.align-center\n",
+        "width=\"90.0%\"}\n",
+        "\n",
+        "**1) State Embedding**\n",
+        "\n",
+        "A latent vector, $\\boldsymbol{z}\\in\\mathbb{R}^N$, is sampled from a\n",
+        "uniform distribution in the interval $[0,\\pi/2)$. All sub-generators\n",
+        "receive the same latent vector which is then embedded using RY gates.\n",
+        "\n",
+        "**2) Parameterised Layers**\n",
+        "\n",
+        "The parameterised layer consists of parameterised RY gates followed by\n",
+        "control Z gates. This layer is repeated $D$ times in total.\n",
+        "\n",
+        "**3) Non-Linear Transform**\n",
+        "\n",
+        "Quantum gates in the circuit model are unitary which, by definition,\n",
+        "linearly transform the quantum state. A linear mapping between the\n",
+        "latent and generator distribution would suffice for only the most simple\n",
+        "generative tasks, hence we need non-linear transformations. We will use\n",
+        "ancillary qubits to help.\n",
+        "\n",
+        "For a given sub-generator, the pre-measurement quantum state is given\n",
+        "by,\n",
+        "\n",
+        "$$|\\Psi(z)\\rangle = U_{G}(\\theta)|\\boldsymbol{z}\\rangle$$\n",
+        "\n",
+        "where $U_{G}(\\theta)$ represents the overall unitary of the\n",
+        "parameterised layers. Let us inspect the state when we take a partial\n",
+        "measurment, $\\Pi$, and trace out the ancillary subsystem, $\\mathcal{A}$,\n",
+        "\n",
+        "$$\\rho(\\boldsymbol{z}) = \\frac{\\text{Tr}_{\\mathcal{A}}(\\Pi \\otimes \\mathbb{I} |\\Psi(z)\\rangle \\langle \\Psi(\\boldsymbol{z})|) }{\\text{Tr}(\\Pi \\otimes \\mathbb{I} |\\Psi(\\boldsymbol{z})\\rangle \\langle \\Psi(\\boldsymbol{z})|))} = \\frac{\\text{Tr}_{\\mathcal{A}}(\\Pi \\otimes \\mathbb{I} |\\Psi(\\boldsymbol{z})\\rangle \\langle \\Psi(\\boldsymbol{z})|) }{\\langle \\Psi(\\boldsymbol{z})| \\Pi \\otimes \\mathbb{I} |\\Psi(\\boldsymbol{z})\\rangle}$$\n",
+        "\n",
+        "The post-measurement state, $\\rho(\\boldsymbol{z})$, is dependent on\n",
+        "$\\boldsymbol{z}$ in both the numerator and denominator. This means the\n",
+        "state has been non-linearly transformed! For this tutorial,\n",
+        "$\\Pi = (|0\\rangle \\langle0|)^{\\otimes N_A}$, where $N_A$ is the number\n",
+        "of ancillary qubits in the system.\n",
+        "\n",
+        "With the remaining data qubits, we measure the probability of\n",
+        "$\\rho(\\boldsymbol{z})$ in each computational basis state, $P(j)$, to\n",
+        "obtain the sub-generator output, $\\boldsymbol{g}^{(i)}$,\n",
+        "\n",
+        "$$\\boldsymbol{g}^{(i)} = [P(0), P(1), ... ,P(2^{N-N_A} - 1)]$$\n",
+        "\n",
+        "**4) Post Processing**\n",
+        "\n",
+        "Due to the normalisation constraint of the measurment, all elements in\n",
+        "$\\boldsymbol{g}^{(i)}$ must sum to one. This is a problem if we are to\n",
+        "use $\\boldsymbol{g}^{(i)}$ as the pixel intensity values for our patch.\n",
+        "For example, imagine a hypothetical situation where a patch of full\n",
+        "intensity pixels was the target. The best patch a sub-generator could\n",
+        "produce would be a patch of pixels all at a magnitude of\n",
+        "$\\frac{1}{2^{N-N_A}}$. To alleviate this constraint, we apply a\n",
+        "post-processing technique to each patch,\n",
+        "\n",
+        "$$\\boldsymbol{\\tilde{x}^{(i)}} = \\frac{\\boldsymbol{g}^{(i)}}{\\max_{k}\\boldsymbol{g}_k^{(i)}}$$\n",
+        "\n",
+        "Therefore, the final image, $\\boldsymbol{\\tilde{x}}$, is given by\n",
+        "\n",
+        "$$\\boldsymbol{\\tilde{x}} = [\\boldsymbol{\\tilde{x}^{(1)}}, ... ,\\boldsymbol{\\tilde{x}^{(N_G)}}]$$\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "id": "ByOocBfSs2V5"
+      },
+      "outputs": [],
+      "source": [
+        "# Quantum variables\n",
+        "n_qubits = 5  # Total number of qubits / N\n",
+        "n_a_qubits = 1  # Number of ancillary qubits / N_A\n",
+        "q_depth = 10  # Depth of the parameterised quantum circuit / D\n",
+        "n_generators = 4  # Number of subgenerators for the patch method / N_G"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Ow6pzPrJs2V5"
+      },
+      "source": [
+        "Now we define the quantum device we want to use, along with any\n",
+        "available CUDA GPUs (if available).\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 23,
+      "metadata": {
+        "id": "hve9vkDEs2V5"
+      },
+      "outputs": [],
+      "source": [
+        "# Quantum simulator\n",
+        "dev = qml.device(\"lightning.qubit\", wires=n_qubits)\n",
+        "# Enable CUDA device if available\n",
+        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Ish10FIUs2V5"
+      },
+      "source": [
+        "Next, we define the quantum circuit and measurement process described\n",
+        "above.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 24,
+      "metadata": {
+        "id": "LNy_ET6ns2V5"
+      },
+      "outputs": [],
+      "source": [
+        "@qml.qnode(dev, interface=\"torch\", diff_method=\"parameter-shift\")\n",
+        "def quantum_circuit(noise, weights):\n",
+        "\n",
+        "    weights = weights.reshape(q_depth, n_qubits)\n",
+        "\n",
+        "    # Initialise latent vectors\n",
+        "    for i in range(n_qubits):\n",
+        "        qml.RY(noise[i], wires=i)\n",
+        "\n",
+        "    # Repeated layer\n",
+        "    for i in range(q_depth):\n",
+        "        # Parameterised layer\n",
+        "        for y in range(n_qubits):\n",
+        "            qml.RY(weights[i][y], wires=y)\n",
+        "\n",
+        "        # Control Z gates\n",
+        "        for y in range(n_qubits - 1):\n",
+        "            qml.CZ(wires=[y, y + 1])\n",
+        "\n",
+        "    return qml.probs(wires=list(range(n_qubits)))\n",
+        "\n",
+        "\n",
+        "# For further info on how the non-linear transform is implemented in Pennylane\n",
+        "# https://discuss.pennylane.ai/t/ancillary-subsystem-measurement-then-trace-out/1532\n",
+        "def partial_measure(noise, weights):\n",
+        "    # Non-linear Transform\n",
+        "    probs = quantum_circuit(noise, weights)\n",
+        "    probsgiven0 = probs[: (2 ** (n_qubits - n_a_qubits))]\n",
+        "    probsgiven0 /= torch.sum(probs)\n",
+        "\n",
+        "    # Post-Processing\n",
+        "    probsgiven = probsgiven0 / torch.max(probsgiven0)\n",
+        "    return probsgiven"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "OG5gYWSvs2V5"
+      },
+      "source": [
+        "Now we create a quantum generator class to use during training.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 25,
+      "metadata": {
+        "id": "n6DbP7d7s2V5"
+      },
+      "outputs": [],
+      "source": [
+        "class PatchQuantumGenerator(nn.Module):\n",
+        "    \"\"\"Quantum generator class for the patch method\"\"\"\n",
+        "\n",
+        "    def __init__(self, n_generators, q_delta=1):\n",
+        "        \"\"\"\n",
+        "        Args:\n",
+        "            n_generators (int): Number of sub-generators to be used in the patch method.\n",
+        "            q_delta (float, optional): Spread of the random distribution for parameter initialisation.\n",
+        "        \"\"\"\n",
+        "\n",
+        "        super().__init__()\n",
+        "\n",
+        "        self.q_params = nn.ParameterList(\n",
+        "            [\n",
+        "                nn.Parameter(q_delta * torch.rand(q_depth * n_qubits), requires_grad=True)\n",
+        "                for _ in range(n_generators)\n",
+        "            ]\n",
+        "        )\n",
+        "        self.n_generators = n_generators\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        # Size of each sub-generator output\n",
+        "        patch_size = 2 ** (n_qubits - n_a_qubits)\n",
+        "\n",
+        "        # Create a Tensor to 'catch' a batch of images from the for loop. x.size(0) is the batch size.\n",
+        "        images = torch.Tensor(x.size(0), 0).to(device)\n",
+        "\n",
+        "        # Iterate over all sub-generators\n",
+        "        for params in self.q_params:\n",
+        "\n",
+        "            # Create a Tensor to 'catch' a batch of the patches from a single sub-generator\n",
+        "            patches = torch.Tensor(0, patch_size).to(device)\n",
+        "            for elem in x:\n",
+        "                q_out = partial_measure(elem, params).float().unsqueeze(0)\n",
+        "                patches = torch.cat((patches, q_out))\n",
+        "\n",
+        "            # Each batch of patches is concatenated with each other to create a batch of images\n",
+        "            images = torch.cat((images, patches), 1)\n",
+        "\n",
+        "        return images"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "hdzKXAD5s2V5"
+      },
+      "source": [
+        "Training\n",
+        "========\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "BJbPX_TSs2V5"
+      },
+      "source": [
+        "Let\\'s define learning rates and number of iterations for the training\n",
+        "process.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 26,
+      "metadata": {
+        "id": "ROVGLoQ0s2V5"
+      },
+      "outputs": [],
+      "source": [
+        "lrG = 0.3  # Learning rate for the generator\n",
+        "lrD = 0.01  # Learning rate for the discriminator\n",
+        "num_iter = 750  # Number of training iterations"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "T-tO_03Ys2V5"
+      },
+      "source": [
+        "Now putting everything together and executing the training process.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 27,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "XaowdvYgs2V5",
+        "outputId": "b15e46e6-6035-4d5f-d40b-9f9f82765392"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Iteration: 10, Discriminator Loss: 1.374, Generator Loss: 0.582\n",
+            "Iteration: 20, Discriminator Loss: 1.355, Generator Loss: 0.595\n",
+            "Iteration: 30, Discriminator Loss: 1.365, Generator Loss: 0.580\n",
+            "Iteration: 40, Discriminator Loss: 1.374, Generator Loss: 0.576\n",
+            "Iteration: 50, Discriminator Loss: 1.352, Generator Loss: 0.589\n",
+            "Iteration: 60, Discriminator Loss: 1.333, Generator Loss: 0.605\n",
+            "Iteration: 70, Discriminator Loss: 1.348, Generator Loss: 0.600\n",
+            "Iteration: 80, Discriminator Loss: 1.314, Generator Loss: 0.599\n",
+            "Iteration: 90, Discriminator Loss: 1.333, Generator Loss: 0.601\n",
+            "Iteration: 100, Discriminator Loss: 1.312, Generator Loss: 0.606\n",
+            "Iteration: 110, Discriminator Loss: 1.279, Generator Loss: 0.629\n",
+            "Iteration: 120, Discriminator Loss: 1.309, Generator Loss: 0.604\n",
+            "Iteration: 130, Discriminator Loss: 1.253, Generator Loss: 0.624\n",
+            "Iteration: 140, Discriminator Loss: 1.315, Generator Loss: 0.604\n",
+            "Iteration: 150, Discriminator Loss: 1.227, Generator Loss: 0.660\n",
+            "Iteration: 160, Discriminator Loss: 1.268, Generator Loss: 0.610\n",
+            "Iteration: 170, Discriminator Loss: 1.306, Generator Loss: 0.599\n",
+            "Iteration: 180, Discriminator Loss: 1.296, Generator Loss: 0.615\n",
+            "Iteration: 190, Discriminator Loss: 1.264, Generator Loss: 0.604\n",
+            "Iteration: 200, Discriminator Loss: 1.321, Generator Loss: 0.589\n",
+            "Iteration: 210, Discriminator Loss: 1.208, Generator Loss: 0.667\n",
+            "Iteration: 220, Discriminator Loss: 1.290, Generator Loss: 0.622\n",
+            "Iteration: 230, Discriminator Loss: 1.236, Generator Loss: 0.628\n",
+            "Iteration: 240, Discriminator Loss: 1.282, Generator Loss: 0.630\n",
+            "Iteration: 250, Discriminator Loss: 1.190, Generator Loss: 0.660\n",
+            "Iteration: 260, Discriminator Loss: 1.343, Generator Loss: 0.585\n",
+            "Iteration: 270, Discriminator Loss: 1.303, Generator Loss: 0.624\n",
+            "Iteration: 280, Discriminator Loss: 1.244, Generator Loss: 0.688\n",
+            "Iteration: 290, Discriminator Loss: 1.269, Generator Loss: 0.641\n",
+            "Iteration: 300, Discriminator Loss: 1.273, Generator Loss: 0.616\n",
+            "Iteration: 310, Discriminator Loss: 1.247, Generator Loss: 0.759\n",
+            "Iteration: 320, Discriminator Loss: 1.323, Generator Loss: 0.612\n",
+            "Iteration: 330, Discriminator Loss: 1.281, Generator Loss: 0.647\n",
+            "Iteration: 340, Discriminator Loss: 1.212, Generator Loss: 0.760\n",
+            "Iteration: 350, Discriminator Loss: 1.322, Generator Loss: 0.636\n",
+            "Iteration: 360, Discriminator Loss: 1.334, Generator Loss: 0.631\n",
+            "Iteration: 370, Discriminator Loss: 1.283, Generator Loss: 0.721\n",
+            "Iteration: 380, Discriminator Loss: 1.209, Generator Loss: 0.685\n",
+            "Iteration: 390, Discriminator Loss: 1.332, Generator Loss: 0.629\n",
+            "Iteration: 400, Discriminator Loss: 1.161, Generator Loss: 0.695\n",
+            "Iteration: 410, Discriminator Loss: 1.340, Generator Loss: 0.630\n",
+            "Iteration: 420, Discriminator Loss: 1.126, Generator Loss: 0.703\n",
+            "Iteration: 430, Discriminator Loss: 1.204, Generator Loss: 0.753\n",
+            "Iteration: 440, Discriminator Loss: 1.124, Generator Loss: 0.735\n",
+            "Iteration: 450, Discriminator Loss: 1.136, Generator Loss: 0.743\n",
+            "Iteration: 460, Discriminator Loss: 1.169, Generator Loss: 0.731\n",
+            "Iteration: 470, Discriminator Loss: 1.054, Generator Loss: 0.785\n",
+            "Iteration: 480, Discriminator Loss: 1.204, Generator Loss: 0.729\n",
+            "Iteration: 490, Discriminator Loss: 1.075, Generator Loss: 0.778\n",
+            "Iteration: 500, Discriminator Loss: 1.227, Generator Loss: 0.644\n",
+            "Iteration: 510, Discriminator Loss: 1.361, Generator Loss: 0.669\n",
+            "Iteration: 520, Discriminator Loss: 1.117, Generator Loss: 0.900\n",
+            "Iteration: 530, Discriminator Loss: 1.147, Generator Loss: 0.704\n",
+            "Iteration: 540, Discriminator Loss: 1.393, Generator Loss: 0.607\n",
+            "Iteration: 550, Discriminator Loss: 0.826, Generator Loss: 1.003\n",
+            "Iteration: 560, Discriminator Loss: 0.917, Generator Loss: 0.837\n",
+            "Iteration: 570, Discriminator Loss: 0.817, Generator Loss: 0.891\n",
+            "Iteration: 580, Discriminator Loss: 0.935, Generator Loss: 0.859\n",
+            "Iteration: 590, Discriminator Loss: 0.901, Generator Loss: 0.958\n",
+            "Iteration: 600, Discriminator Loss: 0.873, Generator Loss: 0.992\n",
+            "Iteration: 610, Discriminator Loss: 0.882, Generator Loss: 1.061\n",
+            "Iteration: 620, Discriminator Loss: 0.701, Generator Loss: 1.179\n",
+            "Iteration: 630, Discriminator Loss: 0.905, Generator Loss: 0.970\n",
+            "Iteration: 640, Discriminator Loss: 0.690, Generator Loss: 0.982\n",
+            "Iteration: 650, Discriminator Loss: 0.588, Generator Loss: 1.334\n",
+            "Iteration: 660, Discriminator Loss: 0.775, Generator Loss: 1.032\n",
+            "Iteration: 670, Discriminator Loss: 0.684, Generator Loss: 1.220\n",
+            "Iteration: 680, Discriminator Loss: 0.762, Generator Loss: 0.978\n",
+            "Iteration: 690, Discriminator Loss: 0.851, Generator Loss: 0.926\n",
+            "Iteration: 700, Discriminator Loss: 0.602, Generator Loss: 1.084\n",
+            "Iteration: 710, Discriminator Loss: 0.613, Generator Loss: 1.526\n",
+            "Iteration: 720, Discriminator Loss: 0.619, Generator Loss: 1.081\n",
+            "Iteration: 730, Discriminator Loss: 0.421, Generator Loss: 1.288\n",
+            "Iteration: 740, Discriminator Loss: 0.351, Generator Loss: 1.587\n",
+            "Iteration: 750, Discriminator Loss: 0.488, Generator Loss: 1.729\n"
+          ]
+        }
+      ],
+      "source": [
+        "discriminator = Discriminator().to(device)\n",
+        "generator = PatchQuantumGenerator(n_generators).to(device)\n",
+        "\n",
+        "# Binary cross entropy\n",
+        "criterion = nn.BCELoss()\n",
+        "\n",
+        "# Optimisers\n",
+        "optD = optim.SGD(discriminator.parameters(), lr=lrD)\n",
+        "optG = optim.SGD(generator.parameters(), lr=lrG)\n",
+        "\n",
+        "real_labels = torch.full((batch_size,), 1.0, dtype=torch.float, device=device)\n",
+        "fake_labels = torch.full((batch_size,), 0.0, dtype=torch.float, device=device)\n",
+        "\n",
+        "# Fixed noise allows us to visually track the generated images throughout training\n",
+        "fixed_noise = torch.rand(8, n_qubits, device=device) * math.pi / 2\n",
+        "\n",
+        "# Iteration counter\n",
+        "counter = 0\n",
+        "\n",
+        "# Collect images for plotting later\n",
+        "results = []\n",
+        "\n",
+        "while True:\n",
+        "    for i, (data, _) in enumerate(dataloader):\n",
+        "\n",
+        "        # Data for training the discriminator\n",
+        "        data = data.reshape(-1, image_size * image_size)\n",
+        "        real_data = data.to(device)\n",
+        "\n",
+        "        # Noise follwing a uniform distribution in range [0,pi/2)\n",
+        "        noise = torch.rand(batch_size, n_qubits, device=device) * math.pi / 2\n",
+        "        fake_data = generator(noise)\n",
+        "\n",
+        "        # Training the discriminator\n",
+        "        discriminator.zero_grad()\n",
+        "        outD_real = discriminator(real_data).view(-1)\n",
+        "        outD_fake = discriminator(fake_data.detach()).view(-1)\n",
+        "\n",
+        "        errD_real = criterion(outD_real, real_labels)\n",
+        "        errD_fake = criterion(outD_fake, fake_labels)\n",
+        "        # Propagate gradients\n",
+        "        errD_real.backward()\n",
+        "        errD_fake.backward()\n",
+        "\n",
+        "        errD = errD_real + errD_fake\n",
+        "        optD.step()\n",
+        "\n",
+        "        # Training the generator\n",
+        "        generator.zero_grad()\n",
+        "        outD_fake = discriminator(fake_data).view(-1)\n",
+        "        errG = criterion(outD_fake, real_labels)\n",
+        "        errG.backward()\n",
+        "        optG.step()\n",
+        "\n",
+        "        counter += 1\n",
+        "\n",
+        "        # Show loss values\n",
+        "        if counter % 10 == 0:\n",
+        "            print(f'Iteration: {counter}, Discriminator Loss: {errD:0.3f}, Generator Loss: {errG:0.3f}')\n",
+        "            test_images = generator(fixed_noise).view(8,1,image_size,image_size).cpu().detach()\n",
+        "\n",
+        "            # Save images every 50 iterations\n",
+        "            if counter % 50 == 0:\n",
+        "                results.append(test_images)\n",
+        "\n",
+        "        if counter == num_iter:\n",
+        "            break\n",
+        "    if counter == num_iter:\n",
+        "        break"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "uDK5G66Bs2V5"
+      },
+      "source": [
+        "::: {.note}\n",
+        "::: {.title}\n",
+        "Note\n",
+        ":::\n",
+        "\n",
+        "You may have noticed `errG = criterion(outD_fake, real_labels)` and\n",
+        "wondered why we don't use `fake_labels` instead of `real_labels`.\n",
+        "However, this is simply a trick to be able to use the same `criterion`\n",
+        "function for both the generator and discriminator. Using `real_labels`\n",
+        "forces the generator loss function to use the $\\log(D(G(z))$ term\n",
+        "instead of the $\\log(1 - D(G(z))$ term of the binary cross entropy loss\n",
+        "function.\n",
+        ":::\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "Xsa1GwZus2V6"
+      },
+      "source": [
+        "Finally, we plot how the generated images evolved throughout training.\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 30,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 332
+        },
+        "id": "fvpigTx8s2V6",
+        "outputId": "98d9cee5-9b3d-4528-acb2-cc66bc7f4996"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 2000x1000 with 120 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "fig = plt.figure(figsize=(20, 10))\n",
+        "outer = gridspec.GridSpec(10, 4, wspace=0.1)\n",
+        "\n",
+        "for i, images in enumerate(results):\n",
+        "    inner = gridspec.GridSpecFromSubplotSpec(1, images.size(0),\n",
+        "                    subplot_spec=outer[i])\n",
+        "\n",
+        "    images = torch.squeeze(images, dim=1)\n",
+        "    for j, im in enumerate(images):\n",
+        "\n",
+        "        ax = plt.Subplot(fig, inner[j])\n",
+        "        ax.imshow(im.numpy(), cmap=\"gray\")\n",
+        "        ax.set_xticks([])\n",
+        "        ax.set_yticks([])\n",
+        "        if j==0:\n",
+        "            ax.set_title(f'Iteration {50+i*50}', loc='left')\n",
+        "        fig.add_subplot(ax)\n",
+        "\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "seconds = time.time()\n",
+        "print(\"Time in seconds since end of run:\", seconds)\n",
+        "local_time = time.ctime(seconds)\n",
+        "print(local_time)"
+      ],
+      "metadata": {
+        "id": "y4dVhN44beWS"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "THvPX4IBs2V6"
+      },
+      "source": [
+        "Acknowledgements\n",
+        "================\n",
+        "\n",
+        "Many thanks to Karolis Špukas who I co-developed much of the code with.\n",
+        "I also extend my thanks to Dr. Yuxuan Du for answering my questions\n",
+        "regarding his paper. I am also indebited to the Pennylane community for\n",
+        "their help over the past few years.\n",
+        "\n",
+        "References\n",
+        "==========\n",
+        "\n",
+        "About the author\n",
+        "================\n"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "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.9.17"
+    },
+    "colab": {
+      "provenance": [],
+      "gpuType": "V100"
+    },
+    "accelerator": "GPU"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
\ No newline at end of file