RCS_benchmark.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5f57c8a3",
   "metadata": {},
   "source": [
    "# RCS 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:24:17.857674: 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.0014786869978706818  seconds,  1.0  out of 1.0 fidelity\n",
      "9 :  0.001409466000040993  seconds,  1.0  out of 1.0 fidelity\n",
      "10 :  0.0025243339987355284  seconds,  1.0  out of 1.0 fidelity\n",
      "11 :  0.004116194002563134  seconds,  1.0  out of 1.0 fidelity\n",
      "12 :  0.004898246999800904  seconds,  1.0  out of 1.0 fidelity\n",
      "13 :  0.00531630600016797  seconds,  1.0  out of 1.0 fidelity\n",
      "14 :  0.008587918997363886  seconds,  1.0  out of 1.0 fidelity\n",
      "15 :  0.008280185000330675  seconds,  1.0  out of 1.0 fidelity\n",
      "16 :  0.009733590999530861  seconds,  1.0  out of 1.0 fidelity\n",
      "17 :  0.010935603997495491  seconds,  1.0  out of 1.0 fidelity\n",
      "18 :  0.013509694999811472  seconds,  1.0  out of 1.0 fidelity\n",
      "19 :  0.023049732997606043  seconds,  1.0  out of 1.0 fidelity\n",
      "20 :  0.04174166699885973  seconds,  1.0  out of 1.0 fidelity\n",
      "21 :  0.07807361899904208  seconds,  1.0  out of 1.0 fidelity\n",
      "22 :  0.16472775299916975  seconds,  1.0  out of 1.0 fidelity\n",
      "23 :  0.3126912360021379  seconds,  1.0  out of 1.0 fidelity\n",
      "24 :  0.6917544790012471  seconds,  1.0  out of 1.0 fidelity\n",
      "25 :  1.4358226399999694  seconds,  1.0  out of 1.0 fidelity\n",
      "26 :  3.3220087380032055  seconds,  1.0  out of 1.0 fidelity\n",
      "27 :  7.042023774996778  seconds,  1.0  out of 1.0 fidelity\n",
      "28 :  16.038140636999742  seconds,  1.0  out of 1.0 fidelity\n"
     ]
    }
   ],
   "source": [
    "def bench_qrack(n):\n",
    "    # This is basically a \"quantum volume\" (random) circuit.\n",
    "    start = time.perf_counter()\n",
    "\n",
    "    sim = QrackSimulator(n)\n",
    "\n",
    "    lcv_range = range(n)\n",
    "    all_bits = list(lcv_range)\n",
    "\n",
    "    single_count = 0\n",
    "    double_count = 0\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",
    "        unused_bits = all_bits.copy()\n",
    "        random.shuffle(unused_bits)\n",
    "        while len(unused_bits) > 1:\n",
    "            sim.mcx([unused_bits.pop()], unused_bits.pop())\n",
    "\n",
    "    fidelity = sim.get_unitary_fidelity()\n",
    "    # Terminal measurement\n",
    "    # print(sim.m_all())\n",
    "    sim.m_all()\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
}