Running_Pennylane_in_AWS_Bracket.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNyOnW5cXxkBuk0ft76QZ2J",
      "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/MonitSharma/Learn-Quantum-Machine-Learning/blob/main/Running_Pennylane_in_AWS_Bracket.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Computing gradients in parallel with Amazon Braket\n",
        "\n",
        "PennyLane integrates with [Amazon Braket](https://aws.amazon.com/braket/) to enable quantum machine learning and optimization on high-performance simulators and quantum processing units (QPUs) through a range of [providers](https://aws.amazon.com/braket/hardware-providers/).\n",
        "\n",
        "In PennyLane, Amazon Braket is accessed through the [PennyLane-Braket](https://amazon-braket-pennylane-plugin-python.readthedocs.io/) plugin. The plugin can be installed using:"
      ],
      "metadata": {
        "id": "QevyXn7gsb9-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Note:\n",
        "\n",
        "To access remote services on Amazon Braket, you must first create an account on AWS and also follow the [setup instructions](https://github.com/aws/amazon-braket-sdk-python#prerequisites) for accessing Braket from Python."
      ],
      "metadata": {
        "id": "4WKIGMW-uHRV"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "czyTqxxCsXaY"
      },
      "outputs": [],
      "source": [
        "!pip install amazon-braket-pennylane-plugin"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A central feature of Amazon Braket is that its remote simulator can execute multiple circuits in parallel. This capability can be harnessed in PennyLane during circuit training, which requires lots of variations of a circuit to be executed. Hence, the PennyLane-Braket plugin provides a method for scalable optimization of large circuits with many parameters. This tutorial will explain the importance of this feature, allow you to benchmark it yourself, and explore its use for solving a scaled-up graph problem with QAOA.\n",
        "\n",
        "\n",
        "\n",
        "![aws bracket](https://pennylane.ai/qml/_images/remote-multi-job-simulator.png)\n"
      ],
      "metadata": {
        "id": "Oz3PbBEhs0v-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Why is training circuits so expensive?\n",
        "\n",
        "Quantum-classical hybrid optimization of quantum circuits is the workhorse algorithm of near-term quantum computing. It is not only fundamental for training variational quantum circuits, but also more broadly for applications like quantum chemistry and quantum machine learning. Today’s most powerful optimization algorithms rely on the efficient computation of gradients—which tell us how to adapt parameters a little bit at a time to improve the algorithm.\n",
        "\n",
        "-----\n",
        "\n",
        "\n",
        "Calculating the gradient involves multiple device executions: for each trainable parameter we must execute our circuit on the device typically more than once. Reasonable applications involve many trainable parameters (just think of a classical neural net with millions of tunable weights). The result is a huge number of device executions for each optimization step.\n",
        "\n",
        "\n",
        "\n",
        "![optimization](https://pennylane.ai/qml/_images/grad-circuits.png)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "------\n",
        "\n",
        "\n",
        "In the standard `default.qubit` device, gradients are calculated in PennyLane through sequential device executions—in other words, all these circuits have to wait in the same queue until they can be evaluated. This approach is simpler, but quickly becomes slow as we scale the number of parameters. Moreover, as the number of qubits, or “width”, of the circuit is scaled, each device execution will slow down and eventually become a noticeable bottleneck. In short—**the future of training quantum circuits relies on high-performance remote simulators and hardware devices that are highly parallelized**.\n",
        "\n",
        "\n",
        "\n",
        "Fortunately, the PennyLane-Braket plugin provides a solution for scalable quantum circuit training by giving access to the Amazon Braket simulator known as [SV1](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html). SV1 is a high-performance state vector simulator that is designed with parallel execution in mind. Together with PennyLane, we can use SV1 to run in parallel all the circuits needed to compute a gradient!\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "7GDYeLFis-3X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Accessing devices on Amazon Braket\n",
        "\n",
        "The remote simulator and quantum hardware devices available on Amazon Braket can be found [here](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html). Each device has a unique identifier known as an [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html). In PennyLane, all remote Braket devices are accessed through a single PennyLane device named `braket.aws.qubit`, along with specification of the corresponding ARN."
      ],
      "metadata": {
        "id": "vSqrxniattvi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let’s load the SV1 simulator in PennyLane with 25 qubits. We must specify both the ARN and the address of the [S3 bucket](https://aws.amazon.com/s3/) where results are to be stored:"
      ],
      "metadata": {
        "id": "0D_NQ9Kft-74"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_bucket = \"amazon-braket-Your-Bucket-Name\"  # the name of the bucket, keep the 'amazon-braket-' prefix and then include the bucket name\n",
        "my_prefix = \"Your-Folder-Name\"  # the name of the folder in the bucket\n",
        "s3_folder = (my_bucket, my_prefix)\n",
        "\n",
        "device_arn = \"arn:aws:braket:::device/quantum-simulator/amazon/sv1\""
      ],
      "metadata": {
        "id": "qhAsX1b3s9ah"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "SV1 can now be loaded with the standard PennyLane `device()`:"
      ],
      "metadata": {
        "id": "wbXjwmbOubN3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pennylane as qml\n",
        "from pennylane import numpy as np\n",
        "\n",
        "n_wires = 25\n",
        "\n",
        "dev_remote = qml.device(\n",
        "    \"braket.aws.qubit\",\n",
        "    device_arn=device_arn,\n",
        "    wires=n_wires,\n",
        "    s3_destination_folder=s3_folder,\n",
        "    parallel=True,\n",
        ")"
      ],
      "metadata": {
        "id": "AWUNUUrIud9d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note the `parallel=True` argument. This setting allows us to unlock the power of parallel execution on SV1 for gradient calculations. We’ll also load `default.qubit` for comparison."
      ],
      "metadata": {
        "id": "D6d-Ku89ujlt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dev_local = qml.device(\"default.qubit\", wires=n_wires)"
      ],
      "metadata": {
        "id": "O_SLtffquoTH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note that a local Braket device `braket.local.qubit` is also available. See the documentation for more details."
      ],
      "metadata": {
        "id": "ECXmcqGvuqwF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Benchmarking circuit evaluationo\n",
        "\n",
        "We will now compare the execution time for the remote Braket SV1 device and `default.qubit`. Our first step is to create a simple circuit:\n",
        "\n"
      ],
      "metadata": {
        "id": "1_2Sh29juwy2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def circuit(params):\n",
        "    for i in range(n_wires):\n",
        "        qml.RX(params[i], wires=i)\n",
        "    for i in range(n_wires):\n",
        "        qml.CNOT(wires=[i, (i + 1) % n_wires])\n",
        "\n",
        "    # Measure all qubits to make sure all's good with Braket\n",
        "    observables = [qml.PauliZ(n_wires - 1)] + [qml.Identity(i) for i in range(n_wires - 1)]\n",
        "    return qml.expval(qml.operation.Tensor(*observables))"
      ],
      "metadata": {
        "id": "CUkwKCMXuv3A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "![circuit](https://pennylane.ai/qml/_images/circuit.png)"
      ],
      "metadata": {
        "id": "uapjiPHUu5xF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this circuit, each of the 25 qubits has a controllable rotation. A final block of two-qubit CNOT gates is added to entangle the qubits. Overall, this circuit has 25 trainable parameters. Although not particularly relevant for practical problems, we can use this circuit as a testbed for our comparison.\n",
        "\n",
        "The next step is to convert the above circuit into a PennyLane `QNode()`."
      ],
      "metadata": {
        "id": "BnrWkaz1u-QI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "qnode_remote = qml.QNode(circuit, dev_remote)\n",
        "qnode_local = qml.QNode(circuit, dev_local)"
      ],
      "metadata": {
        "id": "-dQh260Eu9Sm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Note:\n",
        "The above uses `QNode()` to convert the circuit. In other tutorials, you may have seen the qnode() decorator being used. These approaches are interchangeable, but we use `QNode()` here because it allows us to pair the same circuit to different devices."
      ],
      "metadata": {
        "id": "tK2It8lovIzv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Warning:\n",
        "\n",
        "Running the contents of this tutorial will result in simulation fees charged to your AWS account. We recommend monitoring your usage on the AWS dashboard."
      ],
      "metadata": {
        "id": "9KrJXBngvOtV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Let's compare the execution time between the two"
      ],
      "metadata": {
        "id": "CYnA-fwyvUBl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "\n",
        "params = np.random.random(n_wires)\n",
        "\n",
        "t_0_remote = time.time()\n",
        "qnode_remote(params)\n",
        "t_1_remote = time.time()\n",
        "\n",
        "t_0_local = time.time()\n",
        "qnode_local(params)\n",
        "t_1_local = time.time()\n",
        "\n",
        "print(\"Execution time on remote device (seconds):\", t_1_remote - t_0_remote)\n",
        "print(\"Execution time on local device (seconds):\", t_1_local - t_0_local)"
      ],
      "metadata": {
        "id": "IAgBCw-avN6v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "These timings highlight the advantage of using the Amazon Braket SV1 device for simulations with large qubit numbers. In general, simulation times scale exponentially with the number of qubits, but SV1 is highly optimized and running on AWS remote servers. This allows SV1 to outperform `default.qubit` in this 25-qubit example. The time you see in practice for the remote device will also depend on factors such as your distance to AWS servers.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "## Note:\n",
        "\n",
        "Given these timings, why would anyone want to use `default.qubit`? You should consider using local devices when your circuit has few qubits. In this regime, the latency times of communicating the circuit to a remote server dominate over simulation times, allowing local simulators to be faster.\n"
      ],
      "metadata": {
        "id": "IDoVUYaHvd4_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Benchmarking Gradient calculations\n",
        "\n",
        "Now let us compare the gradient-calculation times between the two devices. Remember that when loading the remote device, we set `parallel=True`. This allows the multiple device executions required during gradient calculations to be performed in parallel, so we expect the remote device to be much faster.\n",
        "\n",
        "First, consider the remote device:\n"
      ],
      "metadata": {
        "id": "c7SNf5iPvr7i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d_qnode_remote = qml.grad(qnode_remote)\n",
        "\n",
        "t_0_remote_grad = time.time()\n",
        "d_qnode_remote(params)\n",
        "t_1_remote_grad = time.time()\n",
        "\n",
        "print(\"Gradient calculation time on remote device (seconds):\", t_1_remote_grad - t_0_remote_grad)"
      ],
      "metadata": {
        "id": "X0IwoqggvqzC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, the local device:\n",
        "\n",
        "\n",
        "## Warning:\n",
        "\n",
        "Evaluating the gradient with default.qubit will take a long time, consider commenting-out the following lines unless you are happy to wait."
      ],
      "metadata": {
        "id": "RerAh-2Ev4_O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "d_qnode_local = qml.grad(qnode_local)\n",
        "\n",
        "t_0_local_grad = time.time()\n",
        "d_qnode_local(params)\n",
        "t_1_local_grad = time.time()\n",
        "\n",
        "print(\"Gradient calculation time on local device (seconds):\", t_1_local_grad - t_0_local_grad)"
      ],
      "metadata": {
        "id": "4ACAoNXav9ly"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The local device needs around 15 minutes or more! Compare this to less than a minute spent calculating the gradient on SV1. This provides a powerful lesson in parallelization.\n",
        "\n",
        "What if we had run on SV1 with `parallel=False`? It would have taken around 3 minutes—still faster than a local device, but much slower than running SV1 in parallel."
      ],
      "metadata": {
        "id": "wC3Wwam7wAfQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Scaling up QAOA for larger graphs\n",
        "\n",
        "The quantum approximate optimization algorithm (QAOA) is a candidate algorithm for near-term quantum hardware that can find approximate solutions to combinatorial optimization problems such as graph-based problems. We have seen in the main [QAOA tutorial](https://colab.research.google.com/github/MonitSharma/Learn-Quantum-Machine-Learning/blob/main/Intro_to_QAOA.ipynb) how QAOA successfully solves the minimum vertex cover problem on a four-node graph.\n",
        "\n",
        "Here, let’s be ambitious and try to solve the maximum cut problem on a twenty-node graph! In maximum cut, the objective is to partition the graph’s nodes into two groups so that the number of edges crossed or ‘cut’ by the partition is maximized (see the diagram below). This problem is NP-hard, so we expect it to be tough as we increase the number of graph nodes.\n",
        "\n",
        "\n",
        "\n",
        "![alt](https://pennylane.ai/qml/_images/max-cut.png)"
      ],
      "metadata": {
        "id": "heVpTSW_wKu9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import networkx as nx\n",
        "\n",
        "nodes = n_wires = 20\n",
        "edges = 60\n",
        "seed = 1967\n",
        "\n",
        "g = nx.gnm_random_graph(nodes, edges, seed=seed)\n",
        "positions = nx.spring_layout(g, seed=seed)\n",
        "\n",
        "nx.draw(g, with_labels=True, pos=positions)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        },
        "id": "4N37Ur1JwJSP",
        "outputId": "a46b7fa0-ff75-497d-963d-eeff444f634f"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We will use the remote SV1 device to help us optimize our QAOA circuit as quickly as possible. First, the device is loaded again for 20 qubits"
      ],
      "metadata": {
        "id": "Zn2J0w8b4tym"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dev = qml.device(\n",
        "    \"braket.aws.qubit\",\n",
        "    device_arn=device_arn,\n",
        "    wires=n_wires,\n",
        "    s3_destination_folder=s3_folder,\n",
        "    parallel=True,\n",
        "    max_parallel=20,\n",
        "    poll_timeout_seconds=30,\n",
        ")"
      ],
      "metadata": {
        "id": "GVdNzgrn4sH1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note the specification of max_parallel=20. This means that up to 20 circuits will be executed in parallel on SV1 (the default value is 10)."
      ],
      "metadata": {
        "id": "eIVM6L_64wsO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Warning:\n",
        "Increasing the maximum number of parallel executions can result in a greater rate of spending on simulation fees on Amazon Braket. The value must also be set bearing in mind your service [quota](https://docs.aws.amazon.com/braket/latest/developerguide/braket-quotas.html)."
      ],
      "metadata": {
        "id": "R55hdoKG4z8V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The QAOA problem can then be set up following the standard pattern, as discussed in detail in the [QAOA tutorial](https://colab.research.google.com/github/MonitSharma/Learn-Quantum-Machine-Learning/blob/main/Intro_to_QAOA.ipynb)."
      ],
      "metadata": {
        "id": "kilG4vWm47qF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cost_h, mixer_h = qml.qaoa.maxcut(g)\n",
        "n_layers = 2\n",
        "\n",
        "\n",
        "def qaoa_layer(gamma, alpha):\n",
        "    qml.qaoa.cost_layer(gamma, cost_h)\n",
        "    qml.qaoa.mixer_layer(alpha, mixer_h)\n",
        "\n",
        "\n",
        "def circuit(params, **kwargs):\n",
        "    for i in range(n_wires):  # Prepare an equal superposition over all qubits\n",
        "        qml.Hadamard(wires=i)\n",
        "\n",
        "    qml.layer(qaoa_layer, n_layers, params[0], params[1])\n",
        "    return qml.expval(cost_h)\n",
        "\n",
        "\n",
        "cost_function = qml.QNode(circuit, dev)\n",
        "optimizer = qml.AdagradOptimizer(stepsize=0.1)"
      ],
      "metadata": {
        "id": "HzPDsPml4zID"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We’re now set up to train the circuit! Note, if you are training this circuit yourself, you may want to increase the number of iterations in the optimization loop and also investigate changing the number of QAOA layers"
      ],
      "metadata": {
        "id": "9cfSwDvg5SkV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Warning:\n",
        "The following lines are computationally intensive. Remember that running it will result in simulation fees charged to your AWS account. We recommend monitoring your usage on the AWS dashboard."
      ],
      "metadata": {
        "id": "jGBG06025T7-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "\n",
        "np.random.seed(1967)\n",
        "params = 0.01 * np.random.uniform(size=[2, n_layers], requires_grad=True)\n",
        "iterations = 10\n",
        "\n",
        "for i in range(iterations):\n",
        "    t0 = time.time()\n",
        "\n",
        "    params, cost_before = optimizer.step_and_cost(cost_function, params)\n",
        "\n",
        "    t1 = time.time()\n",
        "\n",
        "    if i == 0:\n",
        "        print(\"Initial cost:\", cost_before)\n",
        "    else:\n",
        "        print(f\"Cost at step {i}:\", cost_before)\n",
        "\n",
        "    print(f\"Completed iteration {i + 1}\")\n",
        "    print(f\"Time to complete iteration: {t1 - t0} seconds\")\n",
        "\n",
        "print(f\"Cost at step {iterations}:\", cost_function(params))\n",
        "\n",
        "np.save(\"params.npy\", params)\n",
        "print(\"Parameters saved to params.npy\")"
      ],
      "metadata": {
        "id": "z0oLcLR_5IDG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "This example shows us that a 20-qubit QAOA problem can be trained within around 1-2 minutes per iteration by using parallel executions on the Amazon Braket SV1 device to speed up gradient calculations. If this problem were run on default.qubit without parallelization, we would expect for training to take much longer.\n",
        "\n"
      ],
      "metadata": {
        "id": "i1FGf5f65c5E"
      }
    }
  ]
}