--- a
+++ b/Code/All PennyLane QML Demos/22 Quantum GANs 0.64 Loss kkawchak.ipynb
@@ -0,0 +1,990 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "metadata": {
+        "id": "Adv9qCFis2V1",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "outputId": "6031da25-97f1-4790-f416-e3e2d3225184"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Time in seconds since beginning of run: 1693264730.4222255\n",
+            "Mon Aug 28 23:18:50 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": 15,
+      "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": 16,
+      "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": 17,
+      "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": 18,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 102
+        },
+        "id": "dzGFZQyRs2V4",
+        "outputId": "f0e8aea0-63b3-4ede-ba57-1b5bebd60051"
+      },
+      "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": 19,
+      "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": 20,
+      "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": 21,
+      "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": 22,
+      "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": 23,
+      "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": 24,
+      "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 = 500  # 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": 25,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "XaowdvYgs2V5",
+        "outputId": "9d40d53c-6cd8-4d8d-92e9-ceedfb78dcae"
+      },
+      "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"
+          ]
+        }
+      ],
+      "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": 26,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 417
+        },
+        "id": "fvpigTx8s2V6",
+        "outputId": "80be262d-635f-4269-f558-af22312ee315"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 80 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ],
+      "source": [
+        "fig = plt.figure(figsize=(10, 5))\n",
+        "outer = gridspec.GridSpec(5, 2, 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": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 0
+        },
+        "id": "y4dVhN44beWS",
+        "outputId": "e034b58b-afd9-4403-889c-47ad30b8a9be"
+      },
+      "execution_count": 27,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Time in seconds since end of run: 1693266593.7901826\n",
+            "Mon Aug 28 23:49:53 2023\n"
+          ]
+        }
+      ]
+    },
+    {
+      "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
+}