Quantum_Neural_Networks_(Qiskit).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOz6wWTqbgxn4LmXT8N72aX",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Hashhhhhhhh/QCohort6_QML/blob/main/Quantum_Neural_Networks_(Qiskit).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Quantum Neural Networks**\n",
        "\n",
        "QNNs apply this generic principle by combining classical neural networks and parametrized quantum circuits.\n",
        "\n",
        "1. From a machine learning perspective, QNNs are algorithmic models that can be trained to find hidden patterns in data in a similar manner to their classical counterparts. These models can load classical data (inputs) into a quantum state, and later process it with quantum gates parametrized by trainable weights. The output from measuring this state can then be plugged into a loss function to train the weights through backpropagation.\n",
        "\n",
        "2. From a quantum computing perspective, QNNs are quantum algorithms based on parametrized quantum circuits that can be trained in a variational manner using classical optimizers. These circuits contain a feature map (with input parameters) and an ansatz (with trainable weights)\n",
        "\n",
        "The 'NeuralNetwork' class is the interface for all QNNs available in qiskit-machine-learning. NeuralNetworks are “stateless”. They do not contain any training capabilities (these are pushed to the actual algorithms or applications: classifiers, regressors, etc), nor do they store the values for trainable weights."
      ],
      "metadata": {
        "id": "z8XzJ6MKeJ7Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pip install qiskit"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FJXxAG4MsLwy",
        "outputId": "ae11df7e-f0f3-4eb2-827b-23e899ca21f1"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting qiskit\n",
            "  Downloading qiskit-1.1.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (12 kB)\n",
            "Collecting rustworkx>=0.14.0 (from qiskit)\n",
            "  Downloading rustworkx-0.15.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (9.9 kB)\n",
            "Requirement already satisfied: numpy<3,>=1.17 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.25.2)\n",
            "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.1)\n",
            "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.1)\n",
            "Collecting dill>=0.3 (from qiskit)\n",
            "  Downloading dill-0.3.8-py3-none-any.whl.metadata (10 kB)\n",
            "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (2.8.2)\n",
            "Collecting stevedore>=3.0.0 (from qiskit)\n",
            "  Downloading stevedore-5.2.0-py3-none-any.whl.metadata (2.3 kB)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit) (4.12.2)\n",
            "Collecting symengine>=0.11 (from qiskit)\n",
            "  Downloading symengine-0.11.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl.metadata (1.2 kB)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit) (1.16.0)\n",
            "Collecting pbr!=2.1.0,>=2.0.0 (from stevedore>=3.0.0->qiskit)\n",
            "  Downloading pbr-6.0.0-py2.py3-none-any.whl.metadata (1.3 kB)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit) (1.3.0)\n",
            "Downloading qiskit-1.1.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.3 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.3/4.3 MB\u001b[0m \u001b[31m22.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading dill-0.3.8-py3-none-any.whl (116 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m8.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading rustworkx-0.15.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.0 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m13.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading stevedore-5.2.0-py3-none-any.whl (49 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.7/49.7 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading symengine-0.11.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (39.4 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m39.4/39.4 MB\u001b[0m \u001b[31m12.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading pbr-6.0.0-py2.py3-none-any.whl (107 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m107.5/107.5 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: symengine, rustworkx, pbr, dill, stevedore, qiskit\n",
            "Successfully installed dill-0.3.8 pbr-6.0.0 qiskit-1.1.1 rustworkx-0.15.1 stevedore-5.2.0 symengine-0.11.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install pylatexenc"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "x5i2uA-o7rqt",
        "outputId": "fd515440-de83-4600-e45c-6311c039fb44"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting pylatexenc\n",
            "  Downloading pylatexenc-2.10.tar.gz (162 kB)\n",
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/162.6 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m162.6/162.6 kB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Building wheels for collected packages: pylatexenc\n",
            "  Building wheel for pylatexenc (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for pylatexenc: filename=pylatexenc-2.10-py3-none-any.whl size=136817 sha256=fbe0668023a73aa02a94d0ea6273eb978ff3503717d0e8d3daadff18e2c1904c\n",
            "  Stored in directory: /root/.cache/pip/wheels/d3/31/8b/e09b0386afd80cfc556c00408c9aeea5c35c4d484a9c762fd5\n",
            "Successfully built pylatexenc\n",
            "Installing collected packages: pylatexenc\n",
            "Successfully installed pylatexenc-2.10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install qiskit_machine_learning"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6JdpDBsIu-Jo",
        "outputId": "350b871a-ca17-4b71-abda-7f029b88c942"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting qiskit_machine_learning\n",
            "  Downloading qiskit_machine_learning-0.7.2-py3-none-any.whl.metadata (12 kB)\n",
            "Requirement already satisfied: qiskit>=0.44 in /usr/local/lib/python3.10/dist-packages (from qiskit_machine_learning) (1.1.1)\n",
            "Collecting qiskit-algorithms>=0.2.0 (from qiskit_machine_learning)\n",
            "  Downloading qiskit_algorithms-0.3.0-py3-none-any.whl.metadata (4.2 kB)\n",
            "Requirement already satisfied: scipy>=1.4 in /usr/local/lib/python3.10/dist-packages (from qiskit_machine_learning) (1.13.1)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from qiskit_machine_learning) (1.25.2)\n",
            "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit_machine_learning) (5.9.5)\n",
            "Requirement already satisfied: scikit-learn>=1.2.0 in /usr/local/lib/python3.10/dist-packages (from qiskit_machine_learning) (1.3.2)\n",
            "Collecting fastdtw (from qiskit_machine_learning)\n",
            "  Downloading fastdtw-0.3.4.tar.gz (133 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m133.4/133.4 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: setuptools>=40.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit_machine_learning) (71.0.4)\n",
            "Requirement already satisfied: dill>=0.3.4 in /usr/local/lib/python3.10/dist-packages (from qiskit_machine_learning) (0.3.8)\n",
            "Requirement already satisfied: rustworkx>=0.14.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=0.44->qiskit_machine_learning) (0.15.1)\n",
            "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=0.44->qiskit_machine_learning) (1.13.1)\n",
            "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=0.44->qiskit_machine_learning) (2.8.2)\n",
            "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=0.44->qiskit_machine_learning) (5.2.0)\n",
            "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=0.44->qiskit_machine_learning) (4.12.2)\n",
            "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=0.44->qiskit_machine_learning) (0.11.0)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.2.0->qiskit_machine_learning) (1.4.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn>=1.2.0->qiskit_machine_learning) (3.5.0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=0.44->qiskit_machine_learning) (1.16.0)\n",
            "Requirement already satisfied: pbr!=2.1.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=0.44->qiskit_machine_learning) (6.0.0)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=0.44->qiskit_machine_learning) (1.3.0)\n",
            "Downloading qiskit_machine_learning-0.7.2-py3-none-any.whl (97 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m97.8/97.8 kB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading qiskit_algorithms-0.3.0-py3-none-any.whl (308 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m308.6/308.6 kB\u001b[0m \u001b[31m21.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hBuilding wheels for collected packages: fastdtw\n",
            "  Building wheel for fastdtw (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for fastdtw: filename=fastdtw-0.3.4-cp310-cp310-linux_x86_64.whl size=512612 sha256=31db46e975c693b142d057b6fede48e6235f2cfba7dc2e13603f541ad1cee3ea\n",
            "  Stored in directory: /root/.cache/pip/wheels/73/c8/f7/c25448dab74c3acf4848bc25d513c736bb93910277e1528ef4\n",
            "Successfully built fastdtw\n",
            "Installing collected packages: fastdtw, qiskit-algorithms, qiskit_machine_learning\n",
            "Successfully installed fastdtw-0.3.4 qiskit-algorithms-0.3.0 qiskit_machine_learning-0.7.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit import QuantumCircuit\n",
        "from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes\n",
        "from qiskit_machine_learning.circuit.library import QNNCircuit\n",
        "\n",
        "from qiskit_machine_learning.neural_networks import SamplerQNN\n"
      ],
      "metadata": {
        "id": "LIq5cRUIu5ba"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Firstly, Set the algorithmic seed to ensure that the results don’t change between runs."
      ],
      "metadata": {
        "id": "SXqJZqW4wTF4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit_algorithms.utils import algorithm_globals\n",
        "\n",
        "algorithm_globals.random_seed = 42"
      ],
      "metadata": {
        "id": "R7cJ9QcKvJAw"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The two neural network classes provided by the qiskit machine learning are EstimatorQNN and SamplerQNN.\n",
        "The primary step is 'instantiating QNNs'. Instantiating QNNs (Quantum Neural Networks) means creating and initializing a quantum neural network model that you can use for quantum machine learning tasks. Following shows the two ways of doing it:"
      ],
      "metadata": {
        "id": "hNGLNBDMwstU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#1. Estimator QNN : The EstimatorQNN takes in a parametrized quantum circuit as input, as well as an optional quantum mechanical observable, and outputs expectation value computations for the forward pass.\n",
        "#The parametrized circuit has two parameters, one represents a QNN input and the other represents a trainable weight:\n",
        "#RY Gate (qc1.ry(params1[0], 0)): Rotates the qubit around the Y-axis by the parameter input1.\n",
        "#RX Gate (qc1.rx(params1[1], 0)): Rotates the qubit around the X-axis by the parameter weight1.\n",
        "#this is an example of angle encoding\n",
        "#In your code, params1[0] refers to the parameter labeled \"input1\", and params1[1] refers to the parameter labeled \"weight1\".\n",
        "#These parameters can be used to encode classical data into the quantum state by specifying the angles of the rotation gates applied to the qubits.\n",
        "\n",
        "from qiskit.circuit import Parameter\n",
        "from qiskit import QuantumCircuit\n",
        "import matplotlib as mp\n",
        "params1 = [Parameter(\"input1\"), Parameter(\"weight1\")]\n",
        "qc1 = QuantumCircuit(1)\n",
        "#creating a superposition\n",
        "qc1.h(0)\n",
        "# Apply parameterized rotation gates to encode data\n",
        "qc1.ry(params1[0], 0)#This could be a feature of your data that you want the quantum circuit to process.\n",
        "qc1.rx(params1[1], 0) #represent a learnable parameter, similar to the weights in a neural network, that needs to be optimized during the training process. It influences the quantum state and ultimately the output of the circuit.\n",
        "qc1.draw(style=\"clifford\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 63
        },
        "id": "CaVh0otjwc9T",
        "outputId": "6b0b0cde-0cc3-418f-d5b9-73e305bd6017"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   ┌───┐┌────────────┐┌─────────────┐\n",
              "q: ┤ H ├┤ Ry(input1) ├┤ Rx(weight1) ├\n",
              "   └───┘└────────────┘└─────────────┘"
            ],
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">   ┌───┐┌────────────┐┌─────────────┐\n",
              "q: ┤ H ├┤ Ry(input1) ├┤ Rx(weight1) ├\n",
              "   └───┘└────────────┘└─────────────┘</pre>"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " Now create an observable to define the expectation value computation."
      ],
      "metadata": {
        "id": "UBIxvf7O_2rm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit.quantum_info import SparsePauliOp\n",
        "#Instead of storing every element of the tensor product matrix explicitly, which can be very large and mostly zeros, SparsePauliOp stores only the non-zero elements and their positions.\n",
        "# This is particularly useful for operations involving many qubits where the Pauli matrices are mostly identity operators except for a few positions.\n",
        "observable1 = SparsePauliOp.from_list([(\"Y\" * qc1.num_qubits, 1)])\n",
        "#\"Y\" * qc1.num_qubits creates a string of Y Pauli operators, one for each qubit in the circuit. For example, if qc1 has 3 qubits, this would result in \"YYY\".\n"
      ],
      "metadata": {
        "id": "cPpqbw-c8d5M"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Together with the quantum circuit defined above, and the observable we have created, the EstimatorQNN constructor takes in the following keyword arguments:\n",
        "\n",
        "1. estimator: optional primitive instance\n",
        "\n",
        "2. input_params: list of quantum circuit parameters that should be treated as “network inputs”\n",
        "\n",
        "3. weight_params: list of quantum circuit parameters that should be treated as “network weights”"
      ],
      "metadata": {
        "id": "4hX4NaCa_-ti"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit_machine_learning.neural_networks import EstimatorQNN\n",
        "\n",
        "estimator_qnn = EstimatorQNN(\n",
        "    circuit=qc1, observables=observable1, input_params=[params1[0]], weight_params=[params1[1]]\n",
        ")\n",
        "estimator_qnn"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Smk98Ii1_6h2",
        "outputId": "e99a42f0-40a5-4988-b843-5dfc60b13368"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<qiskit_machine_learning.neural_networks.estimator_qnn.EstimatorQNN at 0x7853bbc53430>"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#2. SamplerQNN: directly takes samples from measuring the quantum circuit, it does not require a custom observable.These output samples are interpreted by default as the probabilities of measuring the integer index corresponding to a bitstring.\n",
        "#the SamplerQNN also allows us to specify an interpret function to post-process the samples. This function should be defined so that it takes a measured integer (from a bitstring) and maps it to a new value, i.e. non-negative integer.\n",
        "from qiskit.circuit import ParameterVector\n",
        "\n",
        "inputs2 = ParameterVector(\"input\", 2)#two inputs\n",
        "weights2 = ParameterVector(\"weight\", 4) #4 trainable weights\n",
        "print(inputs2)\n",
        "print(weights2,)\n",
        "\n",
        "qc2 = QuantumCircuit(2)\n",
        "qc2.ry(inputs2[0], 0) #applying ry gate to qubit 0\n",
        "qc2.ry(inputs2[1], 1) #applying ry gate to qubit 1\n",
        "qc2.cx(0, 1)\n",
        "qc2.ry(weights2[0], 0)\n",
        "qc2.ry(weights2[1], 1)\n",
        "qc2.cx(0, 1)\n",
        "qc2.ry(weights2[2], 0)\n",
        "qc2.ry(weights2[3], 1)\n",
        "\n",
        "qc2.draw(style=\"clifford\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "1h4MeJ3mA1Dz",
        "outputId": "55373cdb-8382-4349-b403-3ee535528379"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "input, ['input[0]', 'input[1]']\n",
            "weight, ['weight[0]', 'weight[1]', 'weight[2]', 'weight[3]']\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "     ┌──────────────┐     ┌───────────────┐     ┌───────────────┐\n",
              "q_0: ┤ Ry(input[0]) ├──■──┤ Ry(weight[0]) ├──■──┤ Ry(weight[2]) ├\n",
              "     ├──────────────┤┌─┴─┐├───────────────┤┌─┴─┐├───────────────┤\n",
              "q_1: ┤ Ry(input[1]) ├┤ X ├┤ Ry(weight[1]) ├┤ X ├┤ Ry(weight[3]) ├\n",
              "     └──────────────┘└───┘└───────────────┘└───┘└───────────────┘"
            ],
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">     ┌──────────────┐     ┌───────────────┐     ┌───────────────┐\n",
              "q_0: ┤ Ry(input[0]) ├──■──┤ Ry(weight[0]) ├──■──┤ Ry(weight[2]) ├\n",
              "     ├──────────────┤┌─┴─┐├───────────────┤┌─┴─┐├───────────────┤\n",
              "q_1: ┤ Ry(input[1]) ├┤ X ├┤ Ry(weight[1]) ├┤ X ├┤ Ry(weight[3]) ├\n",
              "     └──────────────┘└───┘└───────────────┘└───┘└───────────────┘</pre>"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from qiskit_machine_learning.neural_networks import SamplerQNN\n",
        "\n",
        "sampler_qnn = SamplerQNN(circuit=qc2, input_params=inputs2, weight_params=weights2)\n",
        "sampler_qnn"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CZEhY6-LHn_X",
        "outputId": "dee27a33-6a18-4a60-d265-f7d27ea6f806"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<qiskit_machine_learning.neural_networks.sampler_qnn.SamplerQNN at 0x7853bce6db70>"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "After the instantiating QNNS, we'd see how to run a forward Pass. 3 steps are involved:\n",
        "1. Set-up (inputs and weights). In a real setting, the inputs would be defined by the dataset, and the weights would be defined by the training algorithm or as part of a pre-trained model.\n",
        "(Here, I am to specify random sets of input and weights of the right dimension)\n",
        "2. Non-batched forward pass: you pass a single set of input data and weights through the quantum circuit to obtain the output.\n",
        "3. Batched forward pass: you pass multiple sets of input data and weights through the quantum circuit simultaneously. This is useful for processing multiple data points in parallel."
      ],
      "metadata": {
        "id": "G69XZ_84H-Es"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#estimatorQNN:(1st step)\n",
        "estimator_qnn_input = algorithm_globals.random.random(estimator_qnn.num_inputs)\n",
        "estimator_qnn_weights = algorithm_globals.random.random(estimator_qnn.num_weights)\n",
        "print(\"input\",estimator_qnn_input)\n",
        "print(\"weight\",estimator_qnn_weights)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wcawObp0H1L6",
        "outputId": "25968654-d834-42a0-a67c-6210d6183bce"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.77395605]\n",
            "[0.43887844]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#samplerQNN(1st step)\n",
        "sampler_qnn_input = algorithm_globals.random.random(sampler_qnn.num_inputs)\n",
        "print(\"Inputs:\",sampler_qnn_input)\n",
        "sampler_qnn_weights = algorithm_globals.random.random(sampler_qnn.num_weights)\n",
        "print(\"Weights:\",sampler_qnn_weights)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uSkO_ycJLvH2",
        "outputId": "f3116dc9-90d2-487f-d856-4ca50753d189"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Inputs: [0.12811363 0.45038594]\n",
            "Weights: [0.37079802 0.92676499 0.64386512 0.82276161]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#estimatorQNN(2nd step):\n",
        "estimator_qnn_forward = estimator_qnn.forward(estimator_qnn_input, estimator_qnn_weights)\n",
        "print(\"EstimatorQNN forward pass:\", estimator_qnn_forward)\n",
        "print(\"Shape\", estimator_qnn_forward.shape)\n",
        "#Shape of forward pass (1,num_qubits*no.of observables)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XyudzaAqMbeM",
        "outputId": "ba81862b-365f-4482-c582-c7d60c929487"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EstimatorQNN forward pass: [[0.2970094]]\n",
            "Shape (1, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#SamplerQNN(2nd step):\n",
        "sampler_qnn_forward = sampler_qnn.forward(sampler_qnn_input, sampler_qnn_weights)\n",
        "print(\"SamplerQNN forward pass:\", sampler_qnn_forward)\n",
        "print(\"Shape\", sampler_qnn_forward.shape)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LWtX5OBtX4oz",
        "outputId": "dd154798-ff59-49ee-b040-8abf449e0fc8"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SamplerQNN forward pass: [[0.15470152 0.06229341 0.57894359 0.20406148]]\n",
            "Shape (1, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#EstimatorQNN(3rd step):\n",
        "\n",
        "estimator_qnn_forward_batched = estimator_qnn.forward(\n",
        "    [estimator_qnn_input, estimator_qnn_input], estimator_qnn_weights)\n",
        "\n",
        "print(\"EstimatorQNN forward pass batched:\", estimator_qnn_forward_batched)\n",
        "print(\"Shape\", estimator_qnn_forward_batched.shape)\n",
        "#For the EstimatorQNN, the expected output shape for the forward pass is (batch_size, num_qubits * num_observables)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YxpP8CLgYcVB",
        "outputId": "58a598b3-08d3-4822-f179-0b1ccfbcbafc"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EstimatorQNN forward pass batched: [[0.2970094]\n",
            " [0.2970094]]\n",
            "Shape (2, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#SamplerQNN(3rd step):\n",
        "sampler_qnn_forward_batched = sampler_qnn.forward(\n",
        "    [sampler_qnn_input, sampler_qnn_input], sampler_qnn_weights\n",
        ")\n",
        "\n",
        "print(\"SamplerQNN forward pass batched:\", sampler_qnn_forward_batched)\n",
        "print(\"Shape\", sampler_qnn_forward_batched.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CxGbOk5NY-WA",
        "outputId": "8f40fb08-49b9-4485-ccc5-8882290a8b3c"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SamplerQNN forward pass batched: [[0.15470152 0.06229341 0.57894359 0.20406148]\n",
            " [0.15470152 0.06229341 0.57894359 0.20406148]]\n",
            "Shape (2, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The next process is running a Backward Pass also called backward propagation. It involves calculating the gradients of the loss function with respect to each of the network's parameters and using these gradients to update the parameters in order to minimize the lossThis pass returns a tuple (input_gradients, weight_gradients). By default, the backward pass will only calculate gradients with respect to the weight parameters.\n",
        "NOTE: Input gradients are required for the use of 'TorchConnector' for PyTorch integration.\n",
        "In QNNs, the backward pass can involve two main steps: one that computes the gradients without considering input gradients, and another that includes the gradients with respect to the inputs.\n",
        "1. Without gradients:  This step is all about figuring out how to adjust the quantum circuit's parameters (like angles for quantum gates) to make the output more accurate.\n",
        "2. With gradients: This step includes not only adjusting the parameters but also figuring out how changes to the input affect the output. This is useful when the input itself can be optimized.\n",
        "\n",
        "In both cases, the goal is to minimize the difference between the current output and the desired output by making smart adjustments based on calculated gradients."
      ],
      "metadata": {
        "id": "cUhuPeq-Zb9q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#estimatorQNN(without gradients):\n",
        "estimator_qnn_input_grad, estimator_qnn_weight_grad = estimator_qnn.backward(\n",
        "    estimator_qnn_input, estimator_qnn_weights\n",
        ")\n",
        "print(\"EstimatorQNN input gradients:\", estimator_qnn_input_grad)\n",
        "\n",
        "print(\"EstimatorQNN weight gradients:\", estimator_qnn_weight_grad)\n",
        "estimator_qnn_weight_grad.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XPmOIQbuZTWo",
        "outputId": "be728c53-36a6-422b-df67-9e6adfdde180"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EstimatorQNN input gradients: None\n",
            "EstimatorQNN weight gradients: [[[0.63272767]]]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 1, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#samplerQNN(without gradients):\n",
        "sampler_qnn_input_grad, sampler_qnn_weight_grad = sampler_qnn.backward(\n",
        "    sampler_qnn_input, sampler_qnn_weights)\n",
        "print(\"SamplerQNN input gradients:\", sampler_qnn_input_grad)\n",
        "print(\"SamplerQNN weight gradients:\", sampler_qnn_weight_grad)\n",
        "sampler_qnn_weight_grad.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v3k1ariicm3N",
        "outputId": "af2bf612-d294-40e1-da0e-d1d621aac8c4"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SamplerQNN input gradients: None\n",
            "SamplerQNN weight gradients: [[[-0.04889532 -0.34600895 -0.09816764 -0.29927154]\n",
            "  [ 0.05721457 -0.02382676  0.09816764 -0.11274611]\n",
            "  [-0.38112659  0.35335087 -0.34371512  0.29927154]\n",
            "  [ 0.37280735  0.01648484  0.34371512  0.11274611]]]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 4, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#estimatorQNN(with gradients)\n",
        "estimator_qnn.input_gradients = True\n",
        "sampler_qnn.input_gradients = True\n",
        "estimator_qnn_input_grad, estimator_qnn_weight_grad = estimator_qnn.backward(\n",
        "    estimator_qnn_input, estimator_qnn_weights)\n",
        "print(\"EstimatorQNN input gradients:\", estimator_qnn_input_grad)\n",
        "print(estimator_qnn_input_grad.shape)\n",
        "print(\"EstimatorQNN weight gradients:\", estimator_qnn_weight_grad)\n",
        "estimator_qnn_weight_grad.shape\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IkcAei3MdPmm",
        "outputId": "9ac9c5c0-2dc1-4707-d3a9-d318f78f78b0"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EstimatorQNN input gradients: [[[0.3038852]]]\n",
            "(1, 1, 1)\n",
            "EstimatorQNN weight gradients: [[[0.63272767]]]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 1, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#samplerQNN(with gradients)\n",
        "sampler_qnn_input_grad, sampler_qnn_weight_grad = sampler_qnn.backward(\n",
        "    sampler_qnn_input, sampler_qnn_weights\n",
        ")\n",
        "print(\"SamplerQNN input gradients:\", sampler_qnn_input_grad)\n",
        "print(sampler_qnn_input_grad.shape)\n",
        "print(\"SamplerQNN weight gradients:\", sampler_qnn_weight_grad)\n",
        "sampler_qnn_weight_grad.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AWXF_Pp_dvmz",
        "outputId": "c6c93632-451d-4180-a32b-4cdc79d019a7"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "SamplerQNN input gradients: [[[-0.08896898 -0.35032267]\n",
            "  [ 0.23452352 -0.03044495]\n",
            "  [-0.18417042  0.3132076 ]\n",
            "  [ 0.03861587  0.06756002]]]\n",
            "(1, 4, 2)\n",
            "SamplerQNN weight gradients: [[[-0.04889532 -0.34600895 -0.09816764 -0.29927154]\n",
            "  [ 0.05721457 -0.02382676  0.09816764 -0.11274611]\n",
            "  [-0.38112659  0.35335087 -0.34371512  0.29927154]\n",
            "  [ 0.37280735  0.01648484  0.34371512  0.11274611]]]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 4, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Estimator QNN with Multiple observables:\n",
        "The EstimatorQNN allows to pass lists of observables for more complex QNN architectures. For example:"
      ],
      "metadata": {
        "id": "v_JT1727eBEz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "observable2 = SparsePauliOp.from_list([(\"Z\" * qc1.num_qubits, 1)])\n",
        "\n",
        "estimator_qnn2 = EstimatorQNN(\n",
        "    circuit=qc1,\n",
        "    observables=[observable1, observable2],\n",
        "    input_params=[params1[0]],\n",
        "    weight_params=[params1[1]],\n",
        ")\n",
        "estimator_qnn_forward2 = estimator_qnn2.forward(estimator_qnn_input, estimator_qnn_weights)\n",
        "estimator_qnn_input_grad2, estimator_qnn_weight_grad2 = estimator_qnn2.backward(\n",
        "    estimator_qnn_input, estimator_qnn_weights\n",
        ")\n",
        "print(\"EstimatorQNN forward pass:\", estimator_qnn_forward2)\n",
        "print(\"Shape\", estimator_qnn_forward2.shape)\n",
        "print(\"EstimatorQNN input gradients:\", estimator_qnn_input_grad2)\n",
        "print(estimator_qnn_weight_grad2.shape)\n",
        "print(\"EstimatorQNN weight gradients:\", estimator_qnn_weight_grad2)\n",
        "estimator_qnn_weight_grad2.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hG_bgw0td6Xi",
        "outputId": "ffa53ece-c803-42b7-aa7d-ae415ee1df1a"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "EstimatorQNN forward pass: [[ 0.2970094  -0.63272767]]\n",
            "Shape (1, 2)\n",
            "EstimatorQNN input gradients: None\n",
            "(1, 2, 1)\n",
            "EstimatorQNN weight gradients: [[[0.63272767]\n",
            "  [0.2970094 ]]]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 2, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "SamplerQNN with custom 'interpret':\n",
        "One common interpret method for SamplerQNN is the parity function, which allows it to perform binary classification.using interpret functions will modify the output shape of the forward and backward passes. In the case of the parity interpret function, output_shape is fixed to 2. Therefore, the expected forward and weight gradient shapes are (batch_size, 2) and (batch_size, 2, num_weights), respectively:"
      ],
      "metadata": {
        "id": "Yg0hQ-Aze9sX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "parity = lambda x: \"{:b}\".format(x).count(\"1\") % 2 #\"{:b}\".format(x) converts the integer x to its binary representation as a string.\n",
        "#lambda x: defines an anonymous function (also known as a lambda function) that takes a single argument x.\n",
        "#.count(\"1\") counts the number of occurrences of the character \"1\" in the binary string.\n",
        "#% 2 calculates the remainder when the count is divided by 2.If the result is 0, the count of 1s is even (parity is even).If the result is 1, the count of 1s is odd (parity is odd).\n",
        "output_shape = 2  # parity = 0, 1\n",
        "\n",
        "sampler_qnn2 = SamplerQNN(\n",
        "    circuit=qc2,\n",
        "    input_params=inputs2,\n",
        "    weight_params=weights2,\n",
        "    interpret=parity,\n",
        "    output_shape=output_shape,\n",
        ")\n",
        "sampler_qnn_forward2 = sampler_qnn2.forward(sampler_qnn_input, sampler_qnn_weights)\n",
        "sampler_qnn_input_grad2, sampler_qnn_weight_grad2 = sampler_qnn2.backward(\n",
        "    sampler_qnn_input, sampler_qnn_weights\n",
        ")\n",
        "\n",
        "print(f\"Forward output for SamplerQNN1: {sampler_qnn_forward.shape}\")\n",
        "print(f\"Forward output for SamplerQNN2: {sampler_qnn_forward2.shape}\")\n",
        "print(f\"Backward output for SamplerQNN1: {sampler_qnn_weight_grad.shape}\")\n",
        "print(f\"Backward output for SamplerQNN2: {sampler_qnn_weight_grad2.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C889kxWFeOHe",
        "outputId": "e7b39661-e0a7-4b97-a4ca-a162c09727a1"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Forward output for SamplerQNN1: (1, 4)\n",
            "Forward output for SamplerQNN2: (1, 2)\n",
            "Backward output for SamplerQNN1: (1, 4, 4)\n",
            "Backward output for SamplerQNN2: (1, 2, 4)\n"
          ]
        }
      ]
    }
  ]
}