examples/pennylane/0_Getting_started/0_Getting_started.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combining PennyLane with Amazon Braket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>What is PennyLane?</b> <a href=\"https://pennylane.ai/install.html\">PennyLane</a> is a Python library for differentiable programming of quantum computers, allowing you to train a quantum computer the same way as a neural network.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"center\"><img src=\"pl_braket.png\"/></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PennyLane integrates with Amazon Braket to add additional features for quantum machine learning and optimization. This introductory tutorial walks you through how to train a quantum circuit using Amazon Braket simulators and PennyLane's automatic differentiation capabilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PennyLane is already installed on Braket notebook instances. On a local machine, PennyLane can be installed by following [these](https://pennylane.ai/install.html) instructions. It can then be imported with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:09.404557Z",
     "start_time": "2024-02-19T21:42:03.275541Z"
    }
   },
   "outputs": [],
   "source": [
    "import pennylane as qml\n",
    "from pennylane import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use Braket as a backend in PennyLane, we have to create a PennyLane device. Here we will first create a device that uses the local Braket simulator that runs on your local laptop (or on the server that hosts this notebook)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:10.351825Z",
     "start_time": "2024-02-19T21:42:09.405882Z"
    }
   },
   "outputs": [],
   "source": [
    "wires = 2  # Number of qubits\n",
    "\n",
    "dev = qml.device(\"braket.local.qubit\", wires=wires)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we will also show you how to scale out simulations to the AWS cloud."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining a circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will choose a simple two-qubit circuit with two controllable rotations and a CNOT gate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:10.355051Z",
     "start_time": "2024-02-19T21:42:10.352639Z"
    }
   },
   "outputs": [],
   "source": [
    "@qml.qnode(dev)\n",
    "def circuit(params):\n",
    "    qml.RX(params[0], wires=0)\n",
    "    qml.RY(params[1], wires=1)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    return qml.expval(qml.PauliZ(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ``qml.qnode(dev)`` decorator binds the circuit to the local Braket device. Now, every time that ``circuit()`` is called, the quantum computation defined in the function above will be executed with Braket."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note</b> PennyLane also supports automatic differentiation with PyTorch and TensorFlow <a href=\"https://pennylane.readthedocs.io/en/stable/introduction/interfaces.html\">interfaces</a>. The choice of interface can be specified using:\n",
    "<code>@qml.qnode(dev, interface=\"&lt;interface&gt;\")</code>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluating the circuit and accessing its gradient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's set some values for our controllable parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:10.359085Z",
     "start_time": "2024-02-19T21:42:10.356833Z"
    }
   },
   "outputs": [],
   "source": [
    "params = np.array([0.1, 0.2], requires_grad=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The circuit can be evaluated with these parameters using"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:10.393070Z",
     "start_time": "2024-02-19T21:42:10.359915Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expectation value of circuit: 0.9751703272018161\n"
     ]
    }
   ],
   "source": [
    "print(\"Expectation value of circuit:\", circuit(params))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:10.397595Z",
     "start_time": "2024-02-19T21:42:10.394259Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Drawing of circuit:\n",
      "\n",
      "0: ──RX(0.10)─╭●─┤     \n",
      "1: ──RY(0.20)─╰X─┤  <Z>\n"
     ]
    }
   ],
   "source": [
    "print(\"Drawing of circuit:\\n\")\n",
    "print(qml.draw(circuit)(params))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A crucial element of machine learning and optimization is accessing the gradient of a model with respect to its parameters. This functionality is built into PennyLane:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:10.400540Z",
     "start_time": "2024-02-19T21:42:10.398616Z"
    }
   },
   "outputs": [],
   "source": [
    "dcircuit = qml.grad(circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, ``dcircuit`` is a callable function that evaluates the gradient of the circuit, i.e., its partial derivatives with respect to the controllable parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:10.523442Z",
     "start_time": "2024-02-19T21:42:10.401286Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.0978434 , -0.19767681])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dcircuit(params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the circuit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we now want to minimize the output of the circuit by updating its parameters. This can be done using gradient-based optimization.\n",
    "\n",
    "First, an optimizer is fixed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:10.526039Z",
     "start_time": "2024-02-19T21:42:10.524244Z"
    }
   },
   "outputs": [],
   "source": [
    "opt = qml.GradientDescentOptimizer(stepsize=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next step is to run the optimizer for a chosen number of iterations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:11.062067Z",
     "start_time": "2024-02-19T21:42:10.527962Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimized circuit output: 0.37261070647126565\n",
      "Optimized parameters: [0.4839502  1.13630274]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "iterations = 20\n",
    "\n",
    "costs = []\n",
    "\n",
    "for i in range(iterations):\n",
    "    params, cost = opt.step_and_cost(circuit, params)\n",
    "    costs.append(cost)\n",
    "\n",
    "# Visualize results\n",
    "costs.append(circuit(params))\n",
    "plt.plot(costs, \"-o\")\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Cost\")\n",
    "\n",
    "print(\"Minimized circuit output:\", circuit(params))\n",
    "print(\"Optimized parameters:\", params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Note</b> The circuit considered here is very simple and can be optimized easily by hand. However, the need for PennyLane's automatic differentiation capabilities becomes apparent as we make the problem more complicated, e.g., with more gates and different types of output measurement. In later demos, we will also see how Braket can be used to parallelize evaluation of the gradient, providing a turbocharger for quantum circuit training in PennyLane.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running circuits on Braket's on-demand simulator, SV1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So far we have used the local Braket simulator. This is a great choice for quick prototyping, but it is not suitable for large circuits with many qubits and does not provide a connection to quantum hardware.\n",
    "\n",
    "Amazon Braket also provides access to on-demand, high-performance simulators and quantum processing units (QPUs) from different [providers](https://aws.amazon.com/braket/hardware-providers/). These devices can be accessed through PennyLane by changing a single line of code, unlocking the potential for machine learning and optimization on quantum hardware and high performance simulators!\n",
    "\n",
    "<div align=\"center\"><img src=\"remote-single-job.png\"/></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:11.066378Z",
     "start_time": "2024-02-19T21:42:11.064297Z"
    }
   },
   "outputs": [],
   "source": [
    "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n",
    "from braket.tracking import Tracker\n",
    "\n",
    "braket_tasks_cost = Tracker().start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each remote Braket device can be selected through its [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html). The supported devices on Braket are listed [here](https://docs.aws.amazon.com/braket/latest/developerguide/braket-devices.html). For now, we will pick the on-demand SV1 simulator.\n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Caution:</b> Running hybrid algorithms on a QPU can take a long time and incur high <a href=\"https://aws.amazon.com/braket/pricing/\">usage fees</a> charged to your AWS account.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "In PennyLane, all remote Braket devices are then accessed through a single PennyLane device named ``braket.aws.qubit``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:11.437758Z",
     "start_time": "2024-02-19T21:42:11.067501Z"
    }
   },
   "outputs": [],
   "source": [
    "from braket.devices import Devices\n",
    "\n",
    "dev = qml.device(\"braket.aws.qubit\", device_arn=Devices.Amazon.SV1, wires=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A follow up [tutorial](./1_Parallelized_optimization_of_quantum_circuits.ipynb) shows you how to use the remote device to run multiple circuits in parallel, while the [QAOA tutorial](./2_Graph_optimization_with_QAOA.ipynb) takes a deeper dive into graph optimization, including using SV1 to optimize a 20-node graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's execute our circuit on SV1, as well as calculating the gradient:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:18.632136Z",
     "start_time": "2024-02-19T21:42:11.439272Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result of circuit run on SV1: 0.37261070647126565\n",
      "Result of gradient calculation on SV1: [-0.19585986 -0.80291741]\n"
     ]
    }
   ],
   "source": [
    "@qml.qnode(dev)\n",
    "def circuit(params):\n",
    "    qml.RX(params[0], wires=0)\n",
    "    qml.RY(params[1], wires=1)\n",
    "    qml.CNOT(wires=[0, 1])\n",
    "    return qml.expval(qml.PauliZ(1))\n",
    "\n",
    "\n",
    "dcircuit = qml.grad(circuit)\n",
    "\n",
    "print(\"Result of circuit run on SV1:\", circuit(params))\n",
    "print(\"Result of gradient calculation on SV1:\", dcircuit(params))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>What's next?</b> Check out the other tutorials in this folder to understand how Braket and PennyLane can be combined to solve a range of problems, from graph optimization to quantum chemistry.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:19.098494Z",
     "start_time": "2024-02-19T21:42:18.633487Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantum Task Summary\n",
      "{<_Amazon.SV1: 'arn:aws:braket:::device/quantum-simulator/amazon/sv1'>: {'shots': 0, 'tasks': {'COMPLETED': 2}, 'execution_duration': datetime.timedelta(microseconds=6000), 'billed_execution_duration': datetime.timedelta(seconds=6)}}\n",
      "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n",
      "Estimated cost to run this example: 0.008 USD\n"
     ]
    }
   ],
   "source": [
    "print(\"Quantum Task Summary\")\n",
    "print(braket_tasks_cost.quantum_tasks_statistics())\n",
    "print(\n",
    "    \"Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\"\n",
    ")\n",
    "print(\n",
    "    f\"Estimated cost to run this example: {braket_tasks_cost.qpu_tasks_cost() + braket_tasks_cost.simulator_tasks_cost():.3f} USD\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running on a QPU with Amazon Braket Hybrid Jobs\n",
    "\n",
    "In this notebook, the classical part of the algorithm was running locally. For longer-running algorithms or those requiring more intensive compute resources, it's recommended to dispatch the algorithm to Amazon Braket Hybrid Jobs, which fully manages the classical infrastructure, allowing you to focus on the algorithm. For example, you can train a larger circuit or increase the number of iterations.\n",
    "\n",
    "The second benefit of running the algorithm as a hybrid job is that for iterative algorithms that require repeated calls to a QPU, you retain priority for that QPU. Once your quantum tasks are created in the hybrid job, they run ahead of other tasks waiting in the regular quantum task queue. This is because hybrid jobs have a separate queue from standalone tasks, ensuring that only a single hybrid job can run on a QPU at a time. This means your algorithm will not be interrupted by other quantum tasks, so it will run more efficiently and predictably. However, hybrid jobs have a separate queue from standalone tasks, so only a single hybrid job can run on a QPU at a time. For a single quantum circuit or a batch of circuits, it's recommended to create quantum tasks instead of hybrid jobs. Only iterative algorithms benefit from QPU priority queuing.\n",
    "\n",
    "Note that hybrid jobs have at least a one-minute startup time since they create a containerized environment on Amazon EC2. So for very short workloads, there is likely no need to create a hybrid job.\n",
    "\n",
    "You can run your local Python code as an Amazon Braket hybrid job by annotating your code with the `@hybrid_job`` decorator, as shown in the following code example. Only Python 3.10 is supported by default. For custom Python versions, you can choose to use a custom container from [Amazon Elastic Container Registry (ECR)](https://aws.amazon.com/ecr/) (see [BYOC](https://docs.aws.amazon.com/braket/latest/developerguide/braket-jobs-byoc.html)).\n",
    "\n",
    "\n",
    "In the following code, we create a hybrid job for 10 iterations targeting Rigetti Ankaa-3. Since we specified Ankaa-3 as the device, this job will run once Ankaa-3 is available and has no jobs running ahead of it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:19.442699Z",
     "start_time": "2024-02-19T21:42:19.099758Z"
    }
   },
   "outputs": [],
   "source": [
    "from braket.jobs import hybrid_job\n",
    "from braket.jobs.metrics import log_metric\n",
    "\n",
    "device_arn = Devices.Amazon.SV1\n",
    "# device_arn = Devices.Rigetti.Ankaa3  # <-- uncomment this line to actually use Ankaa-3, it will cost about 120 USD\n",
    "\n",
    "\n",
    "@hybrid_job(device=device_arn)  # set priority QPU\n",
    "def qubit_rotation(stepsize=0.1, iterations=5):\n",
    "    task_tracker = Tracker().start()  # track Braket quantum tasks costs\n",
    "    dev = qml.device(\"braket.aws.qubit\", device_arn=device_arn.value, wires=2, shots=1_000)\n",
    "\n",
    "    params = np.array([0.1, 0.2])\n",
    "\n",
    "    @qml.qnode(dev)\n",
    "    def circuit(params):\n",
    "        qml.RX(params[0], wires=0)\n",
    "        qml.RY(params[1], wires=1)\n",
    "        qml.CNOT(wires=[0, 1])\n",
    "        return qml.expval(qml.PauliZ(1))\n",
    "\n",
    "    opt = qml.GradientDescentOptimizer(stepsize)\n",
    "\n",
    "    costs = []\n",
    "    for i in range(iterations):\n",
    "        params, cost = opt.step_and_cost(circuit, params)\n",
    "        costs.append(cost)\n",
    "\n",
    "        # Record the value of the cost function with each iteration\n",
    "        log_metric(metric_name=\"cost_function\", value=cost, iteration_number=i)\n",
    "\n",
    "        # Additionally, keep track of cost in USD for Braket tasks\n",
    "        braket_task_cost = float(\n",
    "            task_tracker.qpu_tasks_cost() + task_tracker.simulator_tasks_cost()\n",
    "        )\n",
    "        log_metric(metric_name=\"braket_cost\", value=braket_task_cost, iteration_number=i)\n",
    "\n",
    "    return {\"params\": params, \"costs\": costs, \"braket_tasks_cost\": braket_task_cost}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How long will it take the hybrid job to run? \n",
    "Let's first check if the device is currently available with `AwsDevice(device_arn).is_available()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:19.614223Z",
     "start_time": "2024-02-19T21:42:19.443623Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from braket.aws import AwsDevice\n",
    "\n",
    "AwsDevice(device_arn).is_available"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we check the hybrid job queue depth with `AwsDevice(device_arn).queue_depth().jobs`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:19.958746Z",
     "start_time": "2024-02-19T21:42:19.615073Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0 (1 prioritized hybrid job running)'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AwsDevice(device_arn).queue_depth().jobs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the device is available and there are no hybrid jobs currently running, then it should take about 5 minutes to complete. \n",
    "\n",
    "<div class=\"alert alert-block alert-warning\">\n",
    "<b>Caution:</b> Running the following cell will only run once the QPU is available. This may take a long time and will result in <a href=\"https://aws.amazon.com/braket/pricing/\">usage fees</a> charged to your AWS account. Only uncomment the cell if you are comfortable with the potential wait-time and costs. We recommend monitoring the Billing & Cost Management Dashboard on the AWS console and being aware that hybrid jobs involving a large number of qubits can be costly.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:42:29.440989Z",
     "start_time": "2024-02-19T21:42:19.960142Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AwsQuantumJob('arn':'arn:aws:braket:us-west-1:606892779558:job/d6234c47-fad4-4cda-bf9a-95b1ed20857b')\n"
     ]
    }
   ],
   "source": [
    "job = qubit_rotation(stepsize=0.2, iterations=20)\n",
    "print(job)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the hybrid job has completed, we can retrieve the results with `job.results()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:49:52.814493Z",
     "start_time": "2024-02-19T21:42:29.442078Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'params': tensor([0.7454, 1.9814], requires_grad=True), 'costs': [array(0.928), array(0.904), array(0.9), array(0.91), array(0.886), array(0.852), array(0.812), array(0.778), array(0.744), array(0.664), array(0.596), array(0.486), array(0.35), array(0.258), array(0.278), array(0.104), array(0.062), array(-0.056), array(-0.096), array(-0.212)], 'braket_tasks_cost': 120.0}\n",
      "CPU times: user 675 ms, sys: 51.8 ms, total: 727 ms\n",
      "Wall time: 14min 6s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "results = job.result()\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:50:26.336487Z",
     "start_time": "2024-02-19T21:49:52.820854Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimized circuit output: 0.37261070647126565\n",
      "Optimized parameters: [0.4839502  1.13630274]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(results[\"costs\"], \"o-\")\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Cost\")\n",
    "\n",
    "print(\"Minimized circuit output:\", circuit(params))\n",
    "print(\"Optimized parameters:\", params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-02-19T21:50:26.756331Z",
     "start_time": "2024-02-19T21:50:26.338055Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\n",
      "Estimated cost to run this example: 120.011 USD\n"
     ]
    }
   ],
   "source": [
    "job_cost = job.result()[\"braket_tasks_cost\"]\n",
    "sv1_cost = float(braket_tasks_cost.simulator_tasks_cost())\n",
    "\n",
    "print(\n",
    "    \"Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2).\"\n",
    ")\n",
    "print(f\"Estimated cost to run this example: {job_cost + sv1_cost :.3f} USD\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "3.10.10",
   "language": "python",
   "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.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}