examples/braket_features/Using_the_experimental_local_simulator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the experimental v2 local simulator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This tutorial serves as an introduction to the experimental v2 local simulator for Amazon Braket. This tutorial explains how to use the v2 local simulator and the performance difference you can expect to see."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to set up and use the new local simulator\n",
    "\n",
    "The new local simulator is available as a Python package, [`amazon-braket-simulator-v2`](https://github.com/amazon-braket/amazon-braket-simulator-v2-python). You can install it locally with `pip`. You should `import braket.simulator_v2` as well to install all the backend dependencies. Then, all you need to do is create a `LocalSimulator` object with the `\"braket_sv_v2\"` (state vector) or `\"braket_dm_v2\"` backend names to use the new local simulator. The new local simulator supports qubit counts up to 32 (state vector) or 16 (density matrix). Keep in mind larger qubit counts require more memory!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:54:15.038574Z",
     "start_time": "2023-08-29T21:54:12.272012Z"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# general imports\n",
    "import numpy as np\n",
    "import math\n",
    "import time\n",
    "\n",
    "# AWS imports: Import Braket SDK modules\n",
    "from braket.circuits import Circuit, circuit, noises, Gate, Instruction\n",
    "from braket.devices import LocalSimulator\n",
    "import braket.simulator_v2\n",
    "\n",
    "default_simulator = LocalSimulator(\"braket_sv\")\n",
    "new_sv_simulator  = LocalSimulator(\"braket_sv_v2\")\n",
    "default_dm_simulator = LocalSimulator(\"braket_dm\")\n",
    "new_dm_simulator     = LocalSimulator(\"braket_dm_v2\")\n",
    "\n",
    "n_shots = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two simple examples: The Quantum Fourier Transform with and without noise\n",
    "\n",
    "We already presented the Quantum Fourier Transform (QFT) in [the QFT notebook](../advanced_circuits_algorithms/Quantum_Fourier_Transform/Quantum_Fourier_Transform.ipynb). These circuits have a mix of one- and two-qubit gates so we can compare the efficiency of each simulator's implementation. We will simulate the measurement counts for these circuits on both local simulators. The older local simulator can only simulate up to 18 or so qubits for state-vectors, but the new one can work with substantially more. In this case we will not run up to 32 qubits on the new simulator, because the memory use can become quite substantial. 25 qubits is enough to see that the new simulator can outperform the existing default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:57:31.936079Z",
     "start_time": "2023-08-29T21:57:31.917126Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "@circuit.subroutine(register=True)\n",
    "def qft(qubits):    \n",
    "    \"\"\"\n",
    "    Construct a circuit object corresponding to the Quantum Fourier Transform (QFT)\n",
    "    algorithm, applied to the argument qubits.  Does not use recursion to generate the QFT.\n",
    "    \n",
    "    Args:\n",
    "        qubits (int): The list of qubits on which to apply the QFT\n",
    "    \"\"\"\n",
    "    qftcirc = Circuit()\n",
    "\n",
    "    # get number of qubits\n",
    "    num_qubits = len(qubits)\n",
    "    \n",
    "    for k in range(num_qubits):\n",
    "        # First add a Hadamard gate\n",
    "        qftcirc.h(qubits[k])\n",
    "    \n",
    "        # Then apply the controlled rotations, with weights (angles) defined by the distance to the control qubit.\n",
    "        # Start on the qubit after qubit k, and iterate until the end.  When num_qubits==1, this loop does not run.\n",
    "        for j in range(1,num_qubits - k):\n",
    "            angle = 2*math.pi/(2**(j+1))\n",
    "            qftcirc.cphaseshift(qubits[k+j],qubits[k], angle)\n",
    "            \n",
    "    # Then add SWAP gates to reverse the order of the qubits:\n",
    "    for i in range(math.floor(num_qubits/2)):\n",
    "        qftcirc.swap(qubits[i], qubits[-i-1])\n",
    "        \n",
    "    return qftcirc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-08-29T21:58:24.654423Z",
     "start_time": "2023-08-29T21:57:31.957381Z"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QFT circuit with 5 qubits:\n",
      "Old local simulator runtime: 0.03917956352233887\n",
      "New local simulator runtime: 0.0059778690338134766\n",
      "\n",
      "QFT circuit with 10 qubits:\n",
      "Old local simulator runtime: 0.0754079818725586\n",
      "New local simulator runtime: 0.013960123062133789\n",
      "\n",
      "QFT circuit with 15 qubits:\n",
      "Old local simulator runtime: 0.2364799976348877\n",
      "New local simulator runtime: 0.06110024452209473\n",
      "\n",
      "QFT circuit with 20 qubits:\n",
      "Old local simulator runtime: 4.88277268409729\n",
      "New local simulator runtime: 0.5842669010162354\n",
      "\n"
     ]
    }
   ],
   "source": [
    "qubit_range = range(5, 21, 5)\n",
    "qft_circs   = {}\n",
    "old_results = {}\n",
    "new_results = {}\n",
    "old_durations = {}\n",
    "new_durations = {}\n",
    "for num_qubits in qubit_range:\n",
    "    # generate QFT circuit\n",
    "    qft_circ = qft(range(num_qubits))\n",
    "    old_start = time.time()\n",
    "    old_results[num_qubits] = default_simulator.run(qft_circ, shots=n_shots).result()\n",
    "    old_stop  = time.time()\n",
    "    old_durations[num_qubits] = old_stop - old_start\n",
    "    new_start = time.time()\n",
    "    new_results[num_qubits] = new_sv_simulator.run(qft_circ, shots=n_shots).result()\n",
    "    new_stop  = time.time()\n",
    "    new_durations[num_qubits] = new_stop - new_start\n",
    "    qft_circs[num_qubits] = qft_circ\n",
    "\n",
    "for num_qubits in qubit_range:\n",
    "    print(f\"QFT circuit with {num_qubits} qubits:\")\n",
    "    print(f'Old local simulator runtime: {old_durations[num_qubits]}')\n",
    "    print(f'New local simulator runtime: {new_durations[num_qubits]}')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QFT circuits in the presence of noise\n",
    "\n",
    "As shown in [Simulating Noise on Amazon Braket](./Simulating_Noise_On_Amazon_Braket.ipynb), we can attach noise operations to Braket circuits and use a density matrix simulator to simulate the evolution of the circuit in the presence of these noise channels. The density matrix simulators can simulate half the qubits of their state vector counterparts, so we will simulate noisy QFT circuits up to 12 qubits. We'll define some simple noise channels -- `BitFlip` and `PhaseFlip` -- apply them to the QFT circuit gates, and compare the simulator performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Noisy QFT circuit with 2 qubits:\n",
      "Old noise local simulator runtime: 0.02772045135498047\n",
      "New noise local simulator runtime: 0.005122661590576172\n",
      "\n",
      "Noisy QFT circuit with 4 qubits:\n",
      "Old noise local simulator runtime: 0.06953191757202148\n",
      "New noise local simulator runtime: 0.008308172225952148\n",
      "\n",
      "Noisy QFT circuit with 6 qubits:\n",
      "Old noise local simulator runtime: 0.16034436225891113\n",
      "New noise local simulator runtime: 0.03748893737792969\n",
      "\n",
      "Noisy QFT circuit with 8 qubits:\n",
      "Old noise local simulator runtime: 0.4437224864959717\n",
      "New noise local simulator runtime: 0.20065069198608398\n",
      "\n"
     ]
    }
   ],
   "source": [
    "bit_flip   = noises.BitFlip(probability=0.1)\n",
    "phase_flip = noises.PhaseFlip(probability=0.15)\n",
    "\n",
    "qubit_range = range(2, 9, 2)\n",
    "qft_circs   = {}\n",
    "old_results = {}\n",
    "new_results = {}\n",
    "old_durations = {}\n",
    "new_durations = {}\n",
    "for num_qubits in qubit_range:\n",
    "    # generate QFT circuit\n",
    "    qft_circ = qft(range(num_qubits))\n",
    "    qft_circ.apply_gate_noise(bit_flip)\n",
    "    qft_circ.apply_gate_noise(phase_flip)\n",
    "    \n",
    "    old_start = time.time()\n",
    "    old_results[num_qubits] = default_dm_simulator.run(qft_circ, shots=n_shots).result()\n",
    "    old_stop  = time.time()\n",
    "    old_durations[num_qubits] = old_stop - old_start\n",
    "    new_start = time.time()\n",
    "    new_results[num_qubits] = new_dm_simulator.run(qft_circ, shots=n_shots).result()\n",
    "    new_stop  = time.time()\n",
    "    new_durations[num_qubits] = new_stop - new_start\n",
    "    qft_circs[num_qubits] = qft_circ\n",
    "\n",
    "for num_qubits in qubit_range:\n",
    "    print(f\"Noisy QFT circuit with {num_qubits} qubits:\")\n",
    "    print(f'Old noise local simulator runtime: {old_durations[num_qubits]}')\n",
    "    print(f'New noise local simulator runtime: {new_durations[num_qubits]}')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running circuit batches\n",
    "\n",
    "The new local simulator also has improved support for running *batches* of circuits. To see the effectiveness of this new functionality, we'll run a batch of 5 QFT circuits for varying qubit counts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 QFT circuits with 5 qubits:\n",
      "Old local simulator runtime: 0.7503087520599365\n",
      "New local simulator runtime: 0.23053908348083496\n",
      "\n",
      "20 QFT circuits with 10 qubits:\n",
      "Old local simulator runtime: 1.6170601844787598\n",
      "New local simulator runtime: 0.5473954677581787\n",
      "\n",
      "20 QFT circuits with 15 qubits:\n",
      "Old local simulator runtime: 4.406347274780273\n",
      "New local simulator runtime: 0.6591923236846924\n",
      "\n"
     ]
    }
   ],
   "source": [
    "qubit_range = range(5, 16, 5)\n",
    "qft_circs   = {}\n",
    "old_results = {}\n",
    "new_results = {}\n",
    "old_durations = {}\n",
    "new_durations = {}\n",
    "\n",
    "batch_size = 20\n",
    "\n",
    "for num_qubits in qubit_range:\n",
    "    # generate QFT circuit\n",
    "    qft_circ = qft(range(num_qubits))\n",
    "    old_start = time.time()\n",
    "    batch_circs = [qft_circ for c_ix in range(batch_size)]\n",
    "    old_results[num_qubits] = default_simulator.run_batch(batch_circs, shots=n_shots).results()\n",
    "    old_stop  = time.time()\n",
    "    old_durations[num_qubits] = old_stop - old_start\n",
    "    new_start = time.time()\n",
    "    new_results[num_qubits] = new_sv_simulator.run_batch(batch_circs, shots=n_shots, max_parallel=2).results()\n",
    "    new_stop  = time.time()\n",
    "    new_durations[num_qubits] = new_stop - new_start\n",
    "    qft_circs[num_qubits] = qft_circ\n",
    "\n",
    "for num_qubits in qubit_range:\n",
    "    print(f\"{batch_size} QFT circuits with {num_qubits} qubits:\")\n",
    "    print(f'Old local simulator runtime: {old_durations[num_qubits]}')\n",
    "    print(f'New local simulator runtime: {new_durations[num_qubits]}')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance comparison on a high performance `ml.c5.xlarge` instance type\n",
    "\n",
    "Smaller notebook instances, like the default `ml.t3.medium` type, don't have enough memory to see the performance benefit of the new simulators for larger circuits. Here we include a comparison from a high performance notebook instance, an `ml.c5.xlarge`. First, we look at how `braket_sv_v2` and `braket_dm_v2` compare to their default counterparts for *single* circuits:\n",
    "\n",
    "![Performance comparison for single circuits](single_circuits.png)\n",
    "\n",
    "The data are the same between rows, but the bottom row is plotted with a `log10` y-scale to see the difference across qubit counts.\n",
    "\n",
    "We can also examine the performance for batches:\n",
    "\n",
    "![Performance comparison for circuit batches](batch_circuits.png)\n",
    "\n",
    "Again, the data are the same between rows, but the bottom row is plotted with a `log10` y-scale to see the difference across qubit counts and batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_braket",
   "language": "python",
   "name": "conda_braket"
  },
  "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.14"
  },
  "vscode": {
   "interpreter": {
    "hash": "590fab68195cf107911461461f81d5c472d3d6127f579badfcfad30f03e5cab2"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}