Ipython notebook and plot display updated.

plot_scripts/plot_display_com_prec.py

@@ -0,0 +1,83 @@
+import numpy as np
+import h5py
+import os
+
+import mercury as mr
+
+import sys
+sys.path.append('/plot_scripts/')
+from map_packages_colors_1v1 import *
+from plot_scripts_1v1 import *
+
+# package_str = ['qiskit' , 'cirq', 'qsimcirq', 'pennylane', 'pennylane_l', 'qibo', 'qibojit', 'yao', 'quest', 'qulacs', 'intel_qs_cpp', 'projectq', 'svsim',  'hybridq', 'hiq', 'qcgpu', 'qrack_sch', 'cuquantum_qiskit', 'cuquantum_qsimcirq', 'qpanda']
+
+
+def abs_time_pack(task, package, cc, N_end):
+
+    if task == "Heisenberg dynamics":
+        task = "hdyn"
+    elif task == "Random Quantum Circuit":
+        task = "rqc"
+    elif task == "Quantum Fourier Transform":
+        task = "qft"
+
+    if cc == "Singlethread":
+        cc = "singlethread"
+    elif cc == "Multithread":
+        cc = "multithread"
+    elif cc == "GPU":
+        cc = "gpu"
+
+    fig, ax = plt.subplots()
+
+    dir = os.getcwd()
+
+    if task == 'hdyn' or task == 'qft':
+        N_arr = np.arange(6, N_end, 2)
+    elif task == 'rqc':
+        N_arr = np.arange(12, N_end, 2)
+
+    dat_sp = dir + '/data/{}/{}_{}_sp.h5'.format(task, package, cc)
+    dat_dp = dir + '/data/{}/{}_{}_dp.h5'.format(task, package, cc)
+
+    if not os.path.isfile(dat_sp) and not os.path.isfile(dat_dp):
+        return mr.Md(f"Compute capability {cc} possibly not supported")
+
+    mr.Md(f"TtS performance of simulation packages with different precision")
+
+    if os.path.isfile(dat_sp):
+        h5f_sp = h5py.File(dat_sp, 'r')
+        dat_sp = h5f_sp[storage_dict[package]][:]
+        h5f_sp.close()
+        plot_abs_data_n_arr(N_arr, dat_sp, package+'_'+task+'_{}_'.format(cc)+'sp')
+
+    if os.path.isfile(dat_dp):
+        h5f_dp = h5py.File(dat_dp, 'r')
+        dat_dp = h5f_dp[storage_dict[package]][:]
+        h5f_dp.close()
+        plot_abs_data_n_arr(N_arr, dat_dp, package+'_'+task+'_{}_'.format(cc)+'dp')
+
+    gen_settings(fig, ax, r"N (system size)", r"Time ($t_{package}$)", False, True, True, N_arr[0]-2, N_arr[-1], True, 10**-1, 10**5, "out", None)
+
+    mr.Md("___")
+    mr.Md(f"Relative performance to double precision")
+
+    fig, ax = plt.subplots()
+
+    if os.path.isfile(dat_fst) and os.path.isfile(dat_fmt):
+        plot_comp_data_n_arr(N_arr, dat_dp, dat_dp, package+'_'+task+'_{}_'.format(cc)+'dp')
+        plot_comp_data_n_arr(N_arr, dat_dp, dat_sp, package+'_'+task+'_{}_'.format(cc)+'sp')
+
+    gen_settings(fig, ax, r"N (system size)", r"Relative to double precision", False, True, True, N_arr[0]-2, N_arr[-1], True, 10**-1, 10**3, "out", None)
+
+    # else:
+    #     print(" Re-select the options as the requested option data is not available.")
+
+# pkg_str = ['qiskit' , 'cirq', 'qsimcirq', 'pennylane', 'pennylane_l', 'qibo', 'qibojit', 'yao', 'quest', 'qulacs', 'intel_qs_cpp', 'projectq', 'svsim',  'hybridq', 'hiq', 'qcgpu', 'qrack_sch']
+
+# abs_time_pack("Heisenberg dynamics", 'qsimcirq', 'Double', 36)
+
+# abs_time(pkg_str, task_1, p_com_cap, p_prec)
+# abs_time("Heisenberg dynamics", "Singlethread", "Single", 'qsimcirq')
+# abs_time_pack("Heisenberg dynamics", "Random Quantum Circuit", "Singlethread", "Single", 34)
+# abs_time_pack("Heisenberg dynamics", "Quantum Fourier Transform", "GPU", "Single", 38)

plot_scripts/plot_display_com_prec_all.py

@@ -0,0 +1,218 @@
+import numpy as np
+import h5py
+import os
+
+import mercury as mr
+
+import sys
+sys.path.append('/plot_scripts/')
+from map_packages_colors_all import *
+from plot_scripts_all import *
+
+package_str = ['qiskit' , 'cirq', 'qsimcirq', 'pennylane', 'pennylane_l', 'qibo', 'qibojit', 'yao', 'quest', 'qulacs', 'intel_qs_cpp', 'projectq', 'svsim',  'hybridq', 'hiq', 'qcgpu', 'qrack_sch', 'cuquantum_qiskit', 'cuquantum_qsimcirq', 'qpanda', 'qpp', 'myqlm', 'myqlm_cpp', 'braket']
+
+
+def _build_data_mat(task, cc, pr_1, pr_2, _n_arr):
+
+    dir = os.getcwd()
+
+    data_mat = np.zeros((len(package_str), len(_n_arr)))
+
+    for p_i, pack in enumerate(package_str):
+
+        dat_pr1 = dir + '/data/{}/{}_{}_{}.h5'.format(task, pack, cc, pr_1)
+        dat_pr2 = dir + '/data/{}/{}_{}_{}.h5'.format(task, pack, cc, pr_2)
+
+        if os.path.isfile(dat_pr1) and os.path.isfile(dat_pr2):
+
+            h5f_pr1 = h5py.File(dat_pr1, 'r')
+            dat_pr1 = h5f_pr1[storage_dict[pack]][:]
+            h5f_pr1.close()
+
+            h5f_pr2 = h5py.File(dat_pr2, 'r')
+            dat_pr2 = h5f_pr2[storage_dict[pack]][:]
+            h5f_pr2.close()
+
+            ratio_arr = []
+
+            if len(dat_pr1) == len(dat_pr2):
+                for i, elem in enumerate(dat_pr1):
+                    ratio_arr.append(elem/float(dat_pr2[i]))
+            elif len(dat_pr1) > len(dat_pr2):
+                for i, elem in enumerate(dat_pr2):
+                    ratio_arr.append(dat_pr1[i]/float(elem))
+            elif len(dat_pr2) > len(dat_pr1):
+                for i, elem in enumerate(dat_pr1):
+                    ratio_arr.append(elem/float(dat_pr2[i]))
+
+            if len(_n_arr) > len(ratio_arr):
+                for r_i, rat in enumerate(ratio_arr):
+                    data_mat[p_i, r_i] = rat
+            elif len(_n_arr) < len(ratio_arr):
+                for n_i in range(len(_n_arr)):
+                    data_mat[p_i, n_i] = ratio_arr[n_i]
+            else:
+                for ri, rat_v in enumerate(ratio_arr):
+                    data_mat[p_i, ri] = rat_v
+
+    return data_mat
+
+def abs_time_pack(task, cc, N_end, pr_1, pr_2):
+
+    if task == "Heisenberg dynamics":
+        task = "hdyn"
+    elif task == "Random Quantum Circuit":
+        task = "rqc"
+    elif task == "Quantum Fourier Transform":
+        task = "qft"
+
+    if cc == "Singlethread":
+        cc = 'singlethread'
+    elif cc == "Multithread":
+        cc = 'multithread'
+    elif cc == "GPU":
+        cc = 'gpu'
+
+    if pr_1 == "Single":
+        pr_1 = "sp"
+    elif pr_2 == "Double":
+        pr_2 = "dp"
+
+    if pr_2 == "Single":
+        pr_1 = "sp"
+    elif pr_2 == "Double":
+        pr_2 = "dp"
+
+    fig, ax = plt.subplots()
+
+    dir = os.getcwd()
+
+    if task == 'hdyn' or task == 'qft':
+        N_arr = np.arange(6, N_end, 2)
+    elif task == 'rqc':
+        N_arr = np.arange(12, N_end, 2)
+
+    # if not os.path.isfile(dat_fst) and not os.path.isfile(dat_fmt) and not os.path.isfile(dat_fgpu):
+    #     return mr.Md(f"Precision {pr} possibly not supported")
+
+    data_mat = _build_data_mat(task, cc, pr_1, pr_2, N_arr)
+
+    # params = {'figure.figsize': (10, 10)}
+    # plt.rcParams.update(params)
+    # plt.imshow(data_mat, cmap='OrRd')#, vmin=-16, vmax=0)
+
+    plt.imshow(data_mat, cmap='gist_heat_r', vmin=-1., vmax=10)
+
+    plt.yticks(range(len(pkg_str)), package_str)
+    locs, labels = plt.yticks()
+
+    # plt.setp(labels, rotation=90)
+    plt.xticks(range(len(N_arr)), N_arr)
+    # locs, labels = plt.xticks()
+
+    ax.xaxis.set_major_locator(ticker.AutoLocator())
+    ax.xaxis.set_minor_locator(ticker.AutoMinorLocator())
+
+    plt.colorbar()
+    plt.tight_layout()
+    # plt.savefig(fn)
+    plt.show()
+
+# abs_time_pack("Heisenberg dynamics", "Double", 36, "Singlethread", "Multithread")
+# abs_time_pack("Random Quantum Circuit", "Double", 36, "Singlethread", "Multithread")
+
+def comp_time_pack(task_1, task_2, cc, N_end, pr_1, pr_2):
+
+    if task_1 == "Heisenberg dynamics":
+        task_1 = "hdyn"
+    elif task_1 == "Random Quantum Circuit":
+        task_1 = "rqc"
+    elif task_1 == "Quantum Fourier Transform":
+        task_1 = "qft"
+
+    if task_2 == "Heisenberg dynamics":
+        task_2 = "hdyn"
+    elif task_2 == "Random Quantum Circuit":
+        task_2 = "rqc"
+    elif task_2 == "Quantum Fourier Transform":
+        task_2 = "qft"
+
+    if cc == "Singlethread":
+        cc = 'singlethread'
+    elif cc == "Multithread":
+        cc = 'multithread'
+    elif cc == "GPU":
+        cc = 'gpu'
+
+    if pr_1 == "Single":
+        pr_1 = "sp"
+    elif pr_2 == "Double":
+        pr_2 = "dp"
+
+    fig, ax = plt.subplots()
+
+
+    dir = os.getcwd()
+
+    if task_1 == 'hdyn' or task_1 == 'qft':
+        N_arr_1 = np.arange(6, N_end, 2)
+    elif task_1 == 'rqc':
+        N_arr_1 = np.arange(12, N_end, 2)
+
+    if task_2 == 'hdyn' or task_2 == 'qft':
+        N_arr_2 = np.arange(6, N_end, 2)
+    elif task_2 == 'rqc':
+        N_arr_2 = np.arange(12, N_end, 2)
+
+    data_mat_1 = np.matrix(_build_data_mat(task_1, cc, pr_1, pr_2, N_arr_1))
+    data_mat_2 = np.matrix(_build_data_mat(task_2, cc, pr_1, pr_2, N_arr_2))
+
+    if N_arr_1[0] > N_arr_2[0]:
+        data_mat_2 = data_mat_2[:,3:]
+
+    elif N_arr_1[0] < N_arr_2[0]:
+        data_mat_1 = data_mat_1[:,3:]
+
+    # print(data_mat_1.shape)
+    # print(data_mat_2.shape)
+
+    # plt.imshow(data_mat_1, cmap='OrRd')#, vmin=-16, vmax=0)
+    # plt.show()
+    # plt.imshow(data_mat_2, cmap='OrRd')#, vmin=-16, vmax=0)
+    # plt.show()
+
+    comp_data_mat = np.zeros(data_mat_1.shape)
+
+    for ri in range(comp_data_mat.shape[0]):
+        for ci in range(comp_data_mat.shape[1]):
+            comp_data_mat[ri, ci] = data_mat_1[ri, ci]/data_mat_2[ri, ci]
+
+    # comp_data_mat = np.matrix(data_mat_1) - np.matrix(data_mat_2)
+
+    # params = {'figure.figsize': (10, 10)}
+    # plt.rcParams.update(params)
+
+    # plt.imshow(comp_data_mat, cmap='Spectral')#, vmin=-16, vmax=0)
+    plt.imshow(comp_data_mat, cmap='gist_heat_r', vmin=-0.5)
+
+    plt.yticks(range(len(pkg_str)), package_str)
+    locs, labels = plt.yticks()
+
+    # plt.setp(labels, rotation=90)
+    if N_arr_1[0] > N_arr_2[0]:
+        plt.xticks(range(len(N_arr_1)), N_arr_1)
+    elif N_arr_1[0] < N_arr_2[0]:
+        plt.xticks(range(len(N_arr_2)), N_arr_2)
+    else:
+        plt.xticks(range(len(N_arr_1)), N_arr_1)
+    # locs, labels = plt.xticks()
+
+    ax.xaxis.set_major_locator(ticker.AutoLocator())
+    ax.xaxis.set_minor_locator(ticker.AutoMinorLocator())
+
+    plt.colorbar()
+    plt.tight_layout()
+    # plt.savefig(fn)
+    plt.show()
+
+# comp_time_pack("Heisenberg dynamics", "Random Quantum Circuit", "Double", 36, "Singlethread", "Multithread")

plots_display_all.ipynb

@@ -110,6 +110,7 @@
    "source": [
     "all_flag = mr.Checkbox(value=False, label=\"Compare all\")\n",
     "cc_flag = mr.Checkbox(value=False, label=\"Compare across compute capabilities\")\n",
+    "pr_flag = mr.Checkbox(value=False, label=\"Compare across precision\")\n",
     "ovo_flag = mr.Checkbox(value=False, label=\"Compare one-on-one\")\n",
     "com_task_flag = mr.Checkbox(value=False, label=\"Compare between tasks\")\n",
     "mgpu_flag = mr.Checkbox(value=False, label=\"Multi-GPU\")"
@@ -207,13 +208,14 @@
     }
    ],
    "source": [
-    "flag_arr = [all_flag.value, cc_flag.value, ovo_flag.value, com_task_flag.value, mgpu_flag.value]\n",
+    "flag_arr = [all_flag.value, cc_flag.value, pr_flag.value, ovo_flag.value, com_task_flag.value, mgpu_flag.value]\n",
     "\n",
     "if flag_arr.count(True) == 0 or flag_arr.count(True) > 1:\n",
     "    mr.Md(\"### Performance Benchmarks of quantum simulators\")\n",
     "    mr.Md(\"Options on the left include (please select only one):\")\n",
     "    mr.Md(\"- Compare all: Compare the TtS of all packages and also the performance relative to a given package\")\n",
     "    mr.Md(\"- Compare across compute capabilities: Compare the performance of package(s) with different compute capabilities\")\n",
+    "    mr.Md(\"- Compare across different precision: Compare the performance of package(s) with different precision with fixed compute capability\")\n",
     "    mr.Md(\"- Compare one-on-one: Compare the performance by selecting two different set of parameters\")\n",
     "    mr.Md(\"- Compare between tasks: Compare the performance between two tasks with respect to ratio of gates applied\")\n",
     "    mr.Md(\"- Multi-GPU: Compare the performance between different parameters as a function of the number of GPUs\")\n",
@@ -327,7 +329,80 @@
     "        else:\n",
     "            abs_time_pack(task.value, com_pack.value, prec.value, N_slider.value+2)\n",
     "            \n",
+    "\n",
+    "elif pr_flag.value == True:\n",
+    "    \n",
+    "    import numpy as np\n",
+    "    import h5py\n",
+    "    import os\n",
+    "    \n",
+    "    pr_packages_flag = mr.Checkbox(value=False, label=\"Compare across packages\")\n",
+    "    \n",
+    "    pr_pack_flag = mr.Checkbox(value=False, label=\"Compare a single package\")\n",
+    "    \n",
+    "    if (pr_packages_flag.value == False and pr_pack_flag.value == False) or (pr_packages_flag.value == True and pr_pack_flag.value == True):\n",
+    "        mr.Md(\"The options on the left include:\")\n",
+    "        mr.Md(\"- Performance benchmark across packages with different precision\")\n",
+    "        mr.Md(\"- Performance benchmark of a package with different precision\")\n",
+    "        \n",
+    "    elif pr_packages_flag.value == True:\n",
+    "\n",
+    "        import sys\n",
+    "        \n",
+    "        _p = os.getcwd()\n",
+    "        \n",
+    "        sys.path.append(_p + '/plot_scripts/')\n",
+    "        from map_packages_colors_all import *\n",
+    "        from plot_scripts_all import *\n",
+    "        from plot_display_com_prec_all import *\n",
+    "        \n",
+    "        # params = {'figure.figsize': (5, 5)}\n",
+    "        # plt.rcParams.update(params)\n",
+    "        \n",
+    "        mr.Md(\"Ratio of different precision for different packages\")\n",
+    "        \n",
+    "        task = mr.Select(label=\"Select Task: \", value=\"Heisenberg dynamics\", choices=[\"Heisenberg dynamics\", \"Random Quantum Circuit\", \"Quantum Fourier Transform\"])\n",
+    "        \n",
+    "        cc = mr.Select(label=\"Select Compute Capability : \", value=\"Singlethread\", choices=[\"Singlethread\", \"Multithread\", \"GPU\"])\n",
+    "        \n",
+    "        N_slider = mr.Slider(value=36, min=6, max=36, label=\"Select System size: \", step=2)\n",
+    "        \n",
+    "        com_pr_1 = mr.Select(label=\"Select Precision I: \", value=\"Double\", choices=[\"Single\", \"Double\"])\n",
+    "        com_pr_2 = mr.Select(label=\"Select Precision II: \", value=\"Single\", choices=[\"Single\", \"Double\"])        \n",
+    "        \n",
+    "        abs_time_pack(task.value, cc.value, N_slider.value+2, com_pr_1.value, com_pr_2.value)        \n",
+    "        \n",
+    "        compare_task_flag = mr.Checkbox(value=False, label=\"Compare to other task (ratio):\")\n",
+    "        if compare_task_flag.value == True:\n",
+    "            mr.Md(\"___\")\n",
+    "            mr.Md(\"Comparison to different tasks\")\n",
+    "            task2 = mr.Select(label=\"Select Task: \", value=\"Heisenberg dynamics\", choices=[\"Heisenberg dynamics\", \"Random Quantum Circuit\", \"Quantum Fourier Transform\"])\n",
+    "            comp_time_pack(task.value, task2.value, cc.value, N_slider.value+2, com_pr_1.value, com_pr_2.value)\n",
+    "            \n",
+    "    elif cc_pack_flag.value == True:\n",
+    "        \n",
+    "        import sys\n",
+    "        \n",
+    "        _p = os.getcwd()\n",
+    "        \n",
+    "        sys.path.append(_p + '/plot_scripts/')\n",
+    "        from map_packages_colors_1v1 import *\n",
+    "        from plot_scripts_1v1 import *\n",
+    "        from plot_display_com_prec import *\n",
+    "    \n",
+    "        task = mr.Select(label=\"Select Task: \", value=\"Heisenberg dynamics\", choices=[\"Heisenberg dynamics\", \"Random Quantum Circuit\", \"Quantum Fourier Transform\"])\n",
+    "\n",
+    "        com_pack = mr.Select(label=\"Select Package to compare: \", value=\"qsimcirq\", choices=['qiskit' , 'cirq', 'qsimcirq', 'pennylane', 'pennylane_l', 'qibo', 'qibojit', 'yao', 'quest', 'qulacs', 'intel_qs_cpp', 'projectq', 'svsim',  'hybridq', 'hiq', 'qcgpu', 'qrack_sch', 'cuquantum_qiskit', 'cuquantum_qsimcirq', 'qpanda', 'qpp', 'myqlm', 'myqlm_cpp', 'braket'])\n",
     "    \n",
+    "        cc = mr.Select(label=\"Select Compute Capability : \", value=\"Singlethread\", choices=[\"Singlethread\", \"Multithread\", \"GPU\"])\n",
+    "    \n",
+    "        N_slider = mr.Slider(value=36, min=6, max=36, label=\"Select System size: \", step=2)\n",
+    "    \n",
+    "        if task.value == \"Random Quantum Circuit\" and N_slider.value < 12:\n",
+    "            mr.Md(\"### Please select a different final N value\")\n",
+    "        else:\n",
+    "            abs_time_pack(task.value, com_pack.value, cc.value, N_slider.value+2)\n",
+    "            \n",
     "        \n",
     "elif ovo_flag.value == True:\n",
     "    \n",