RCS_nearest-neighbor_benchmark.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5f57c8a3",
   "metadata": {},
   "source": [
    "# RCS (Nearest-Neighbor) Benchmark"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48d34546-e54a-442f-85c5-e9a28d7c38d1",
   "metadata": {},
   "source": [
    "## Getting Started"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b171b3b-012c-4dad-870a-e8be44c24128",
   "metadata": {},
   "source": [
    "You need [`pyqrack`](https://pypi.org/project/pyqrack/) to run this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b921e879-46df-4382-a1c7-804b6f2d0854",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For example, if your Jupyter installation uses pip:\n",
    "# import sys\n",
    "# !{sys.executable} -m pip install pyqrack"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e55837c-018f-4cb2-a9cb-86f356d7a2d8",
   "metadata": {},
   "source": [
    "In the Python package itself, there should be an executable called `qrack_cl_precompile`. This \"pre-compiles\" the OpenCL \"just-in-time\" (\"JIT\") device program, for your system's accelerators. You might want to find and run this utility first, to avoid the need to \"recompile\" the OpenCL device program every time you first load Qrack into your environment."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0b34caa-b73e-4059-a27b-ad3e828a623d",
   "metadata": {},
   "source": [
    "## Configuration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "90b257ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lowest qubit width\n",
    "low = 8\n",
    "# Highest qubit width\n",
    "high = 28\n",
    "# Samples to average per qubit width\n",
    "samples = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1f21a89b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-21 12:23:18.697783: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import os\n",
    "import random\n",
    "import time\n",
    "\n",
    "from pyqrack import QrackSimulator\n",
    "\n",
    "# For more specific details about all available Qrack environment variables,\n",
    "# See the C++ repository README: https://github.com/unitaryfund/qrack\n",
    "\n",
    "# This is the maximum total number of fully-entangled qubits you expect to fit in general RAM.\n",
    "os.environ['QRACK_MAX_CPU_QB']='32'\n",
    "\n",
    "# Above this threshold, \"QTensorNetwork\" restricts simulations to \"past light cone.\"\n",
    "# At or below the threshold, much more work can be reused.\n",
    "os.environ['QRACK_QTENSORNETWORK_THRESHOLD_QB']='-1'\n",
    "\n",
    "# These below are approximation options. (By default, Qrack simulates in the \"ideal.\")\n",
    "\n",
    "# This is a number between \"0\" (\"ideal\") and \"1\" (\"round to exactly Clifford\") for near-Clifford rounding.\n",
    "# os.environ['QRACK_NONCLIFFORD_ROUNDING_THRESHOLD']='1\n",
    "\n",
    "# This is a number between \"0\" (\"ideal\") and \"1\" (\"destroy all entanglement\") for \"SDRP,\"\n",
    "# \"Schmidt decomposition rounding parameter\". (https://arxiv.org/abs/2304.14969)\n",
    "# os.environ['QRACK_QUNIT_SEPARABILITY_THRESHOLD']='0.6'\n",
    "\n",
    "# This is a number between \"0\" (\"ideal\") and \"1\" (\"combine all binary decision tree branches\")\n",
    "# that sets the allowable \"epsilon\" between \"QBdt\" branches to consider them equal.\n",
    "# os.environ['QRACK_QBDT_SEPARABILITY_THRESHOLD']='0.0001'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb4ef620",
   "metadata": {},
   "source": [
    "## Run the Benchmark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9e742f47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Device #0, Loaded binary from: /home/iamu/.qrack/qrack_ocl_dev_NVIDIA_GeForce_RTX_2070_Super.ir\n",
      "8 :  0.0012601050002558623  seconds,  1.0  out of 1.0 fidelity\n",
      "9 :  0.0012051500016241334  seconds,  1.0  out of 1.0 fidelity\n",
      "10 :  0.001945197000168264  seconds,  1.0  out of 1.0 fidelity\n",
      "11 :  0.003307540999230696  seconds,  1.0  out of 1.0 fidelity\n",
      "12 :  0.0046881249982106965  seconds,  1.0  out of 1.0 fidelity\n",
      "13 :  0.0052512990005197935  seconds,  1.0  out of 1.0 fidelity\n",
      "14 :  0.0063723490020493045  seconds,  1.0  out of 1.0 fidelity\n",
      "15 :  0.008712006001587724  seconds,  1.0  out of 1.0 fidelity\n",
      "16 :  0.009200592001434416  seconds,  1.0  out of 1.0 fidelity\n",
      "17 :  0.011679193001327803  seconds,  1.0  out of 1.0 fidelity\n",
      "18 :  0.013783976999548031  seconds,  1.0  out of 1.0 fidelity\n",
      "19 :  0.03011050399800297  seconds,  1.0  out of 1.0 fidelity\n",
      "20 :  0.03861674099971424  seconds,  1.0  out of 1.0 fidelity\n",
      "21 :  0.07456181700035813  seconds,  1.0  out of 1.0 fidelity\n",
      "22 :  0.13901854399955482  seconds,  1.0  out of 1.0 fidelity\n",
      "23 :  0.3083601219987031  seconds,  1.0  out of 1.0 fidelity\n",
      "24 :  0.6213324640011706  seconds,  1.0  out of 1.0 fidelity\n",
      "25 :  1.429095364001114  seconds,  1.0  out of 1.0 fidelity\n",
      "26 :  2.8003156909981044  seconds,  1.0  out of 1.0 fidelity\n",
      "27 :  6.180590911000763  seconds,  1.0  out of 1.0 fidelity\n",
      "28 :  14.248559002000547  seconds,  1.0  out of 1.0 fidelity\n"
     ]
    }
   ],
   "source": [
    "def cx(circ, q1, q2):\n",
    "    circ.mcx([q1], q2)\n",
    "\n",
    "def cy(circ, q1, q2):\n",
    "    circ.mcy([q1], q2)\n",
    "\n",
    "def cz(circ, q1, q2):\n",
    "    circ.mcz([q1], q2)\n",
    "\n",
    "def acx(circ, q1, q2):\n",
    "    circ.macx([q1], q2)\n",
    "\n",
    "def acy(circ, q1, q2):\n",
    "    circ.macy([q1], q2)\n",
    "\n",
    "def acz(circ, q1, q2):\n",
    "    circ.macz([q1], q2)\n",
    "\n",
    "def swap(circ, q1, q2):\n",
    "    circ.swap(q1, q2)\n",
    "\n",
    "def nswap(circ, q1, q2):\n",
    "    circ.macz([q1], q2)\n",
    "    circ.swap(q1, q2)\n",
    "    circ.macz([q1], q2)\n",
    "\n",
    "def pswap(circ, q1, q2):\n",
    "    circ.macz([q1], q2)\n",
    "    circ.swap(q1, q2)\n",
    "\n",
    "def mswap(circ, q1, q2):\n",
    "    circ.swap(q1, q2)\n",
    "    circ.macz([q1], q2)\n",
    "\n",
    "def iswap(circ, q1, q2):\n",
    "    circ.iswap(q1, q2)\n",
    "\n",
    "def iiswap(circ, q1, q2):\n",
    "    circ.adjiswap(q1, q2)\n",
    "\n",
    "def bench_qrack(n):\n",
    "    # This is a circuit with nearest-neighbor couplers that aims for high Haar-randomness.\n",
    "    lcv_range = range(n)\n",
    "    gateSequence = [ 0, 3, 2, 1, 2, 1, 0, 3 ]\n",
    "    row_len = math.ceil(math.sqrt(n))\n",
    "    two_bit_gates = swap, pswap, mswap, nswap, iswap, iiswap, cx, cy, cz, acx, acy, acz\n",
    "\n",
    "    start = time.perf_counter()\n",
    "\n",
    "    sim = QrackSimulator(n)\n",
    "\n",
    "    for _ in lcv_range:\n",
    "        # Single-qubit gates\n",
    "        for i in lcv_range:\n",
    "            sim.u(i, random.uniform(0, 2 * math.pi), random.uniform(0, 2 * math.pi), random.uniform(0, 2 * math.pi))\n",
    "\n",
    "        # 2-qubit couplers\n",
    "        gate = gateSequence.pop(0)\n",
    "        gateSequence.append(gate)\n",
    "        for row in range(1, row_len, 2):\n",
    "            for col in range(row_len):\n",
    "                temp_row = row\n",
    "                temp_col = col\n",
    "                temp_row = temp_row + (1 if (gate & 2) else -1);\n",
    "                temp_col = temp_col + (1 if (gate & 1) else 0)\n",
    "\n",
    "                if (temp_row < 0) or (temp_col < 0) or (temp_row >= row_len) or (temp_col >= row_len):\n",
    "                    # Row and/or column selected were out of range\n",
    "                    continue\n",
    "\n",
    "                b1 = row * row_len + col\n",
    "                b2 = temp_row * row_len + temp_col\n",
    "\n",
    "                if (b1 >= n) or (b2 >= n):\n",
    "                    # Bits selected were out-of-range\n",
    "                    continue\n",
    "\n",
    "                # Swap bits, 50% of the time\n",
    "                if random.randint(0, 1) == 1:\n",
    "                    temp = b1\n",
    "                    b1 = b2\n",
    "                    b2 = temp\n",
    "                \n",
    "                g = random.choice(two_bit_gates)\n",
    "                g(sim, b1, b2)\n",
    "\n",
    "    fidelity = 1\n",
    "    try:\n",
    "        fidelity = sim.get_unitary_fidelity()\n",
    "        # Terminal measurement\n",
    "        sim.m_all()\n",
    "    except:\n",
    "        fidelity = 0\n",
    "\n",
    "    return (time.perf_counter() - start, fidelity)\n",
    "\n",
    "# Make sure the OpenCL environment is initialized before timing.\n",
    "# (You probably also want to precompile OpenCL kernels with the `qrack_cl_precompile` utility, in general.)\n",
    "bench_qrack(1)\n",
    "\n",
    "time_results = {}\n",
    "fidelity_results = {}\n",
    "for n in range(low, high + 1):\n",
    "    width_results = []\n",
    "        \n",
    "    # Run the benchmarks\n",
    "    for i in range(samples):\n",
    "        width_results.append(bench_qrack(n))\n",
    "\n",
    "    time_results[n] = sum(r[0] for r in width_results) / samples\n",
    "    fidelity_results[n] = sum(r[1] for r in width_results) / samples\n",
    "    print(n, \": \", time_results[n], \" seconds, \", fidelity_results[n], \" out of 1.0 fidelity\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}