From b6fa19c3a9b43144d5a10d884415985bda6b913b Mon Sep 17 00:00:00 2001 From: Alexander Kunitsa <28026247+aakunitsa@users.noreply.github.com> Date: Wed, 4 Dec 2024 11:06:24 -0500 Subject: [PATCH 01/25] added overlaps for all planted solution instances, an example notebook and utils --- examples/csf_weight.ipynb | 918 ++++++++++++++++++++++++++++ scripts/overlaps.csv | 16 +- src/qb_gsee_benchmark/cas_utils.py | 14 + src/qb_gsee_benchmark/dmrg_utils.py | 72 +++ 4 files changed, 1016 insertions(+), 4 deletions(-) create mode 100644 examples/csf_weight.ipynb create mode 100644 src/qb_gsee_benchmark/cas_utils.py create mode 100644 src/qb_gsee_benchmark/dmrg_utils.py diff --git a/examples/csf_weight.ipynb b/examples/csf_weight.ipynb new file mode 100644 index 0000000..c610d28 --- /dev/null +++ b/examples/csf_weight.ipynb @@ -0,0 +1,918 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import h5py, os, glob, json\n", + "from block2 import SU2\n", + "from pyblock2.driver.core import DMRGDriver, SymmetryTypes\n", + "import pandas as pd\n", + "import numpy as np\n", + "from dmrg_utils import load_mps, max_det_coeff, expand_csf\n", + "from cas_utils import log_hilbert_space_size\n", + "from matplotlib import pyplot as plt\n", + "from pathlib import Path\n", + "import urllib.request" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# General parameters\n", + "repository_url = \"https://github.com/isi-usc-edu/qb-gsee-benchmark/archive/refs/heads/main.zip\"\n", + "problem_instance_files_repository_path = (\n", + " \"problem_instances\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Download problem instance files\n", + "repository_filepath = Path(\"repository.zip\")\n", + "\n", + "repository_path = Path(\"qb-gsee-benchmark-main\")\n", + "if not repository_path.exists():\n", + " # Download repository\n", + " urllib.request.urlretrieve(repository_url, repository_filepath.name)\n", + " # unzip repository\n", + " os.system(f\"unzip {repository_filepath}\")\n", + "\n", + "problem_instance_files_path = repository_path / problem_instance_files_repository_path\n", + "instance_files = list(problem_instance_files_path.glob('problem_instance.planted_solution_*.json'))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Retrieve relevant metadata\n", + "metadata = []\n", + "\n", + "for file in instance_files:\n", + " with open(file, 'r') as jf:\n", + " json_data = json.load(jf)\n", + " \n", + " \n", + " for task_data in json_data['tasks']:\n", + " features = dict(task_data['features'])\n", + " assert len(task_data['supporting_files']) == 1 \n", + " features = {**features, **(task_data['supporting_files'][0])}\n", + " features['reference_energy'] = task_data['requirements'].get('reference_energy')\n", + " features['reference_energy_units'] = task_data['requirements'].get('reference_energy_units')\n", + " features['task_uuid'] = task_data['task_uuid']\n", + "\n", + " file_name = os.path.basename(file)\n", + " features['prob_file_name'] = file_name\n", + "\n", + " metadata.append(features)\n", + "\n", + "metadata = pd.DataFrame(metadata)\n", + "metadata['prob_name_wo_uuid'] = metadata.apply(lambda r: r['prob_file_name'].split('.')[1], axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " prob_name_wo_uuid solution_dir\n", + "0 planted_solution_0004 ../data/data_storage/planted_solution_0004.7e0...\n" + ] + } + ], + "source": [ + "mps_data_dir = Path('../data/data_storage/') # Location of MPSs; in this example - for planted solutions\n", + "list_of_solution_dirs = list(mps_data_dir.glob('planted_solution_*'))\n", + "solution_paths = []\n", + "for sol_dir in list_of_solution_dirs:\n", + " prob_name = os.path.basename(sol_dir).split('.')[0]\n", + " solution_paths.append({'prob_name_wo_uuid' : prob_name, 'solution_dir' : sol_dir})\n", + "sol_paths = pd.DataFrame(solution_paths)\n", + "print(sol_paths.head(1))" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
multiplicitynum_electronsnum_orbitalsutility_scaleinstance_data_object_uuidinstance_data_object_urlinstance_data_checksuminstance_data_checksum_typereference_energyreference_energy_unitstask_uuidprob_file_nameprob_name_wo_uuidsolution_dirlog10_hs_size
015031Falseefddd28a-383d-4929-9335-22e54ba2ffbesftp://sftp.l3harris.com/gsee/planted_solution...48e4bda8ad2e48926e8b7c36ea24f1e16ab8edf2sha1sum-581.589915hartree472bbfb1-c081-4df6-b966-32ce1194ab8cproblem_instance.planted_solution_0003.a37c86c...planted_solution_0003../data/data_storage/planted_solution_0003.70f...11.734087
\n", + "
" + ], + "text/plain": [ + " multiplicity num_electrons num_orbitals utility_scale \\\n", + "0 1 50 31 False \n", + "\n", + " instance_data_object_uuid \\\n", + "0 efddd28a-383d-4929-9335-22e54ba2ffbe \n", + "\n", + " instance_data_object_url \\\n", + "0 sftp://sftp.l3harris.com/gsee/planted_solution... \n", + "\n", + " instance_data_checksum instance_data_checksum_type \\\n", + "0 48e4bda8ad2e48926e8b7c36ea24f1e16ab8edf2 sha1sum \n", + "\n", + " reference_energy reference_energy_units \\\n", + "0 -581.589915 hartree \n", + "\n", + " task_uuid \\\n", + "0 472bbfb1-c081-4df6-b966-32ce1194ab8c \n", + "\n", + " prob_file_name prob_name_wo_uuid \\\n", + "0 problem_instance.planted_solution_0003.a37c86c... planted_solution_0003 \n", + "\n", + " solution_dir log10_hs_size \n", + "0 ../data/data_storage/planted_solution_0003.70f... 11.734087 " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "metadata = metadata.join(sol_paths.set_index('prob_name_wo_uuid'), on='prob_name_wo_uuid', how='left')\n", + "metadata['log10_hs_size'] = metadata.apply(lambda r: log_hilbert_space_size(r['num_orbitals'], \n", + " r['num_electrons'], r['multiplicity']), axis=1)\n", + "metadata.head(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
prob_name_wo_uuidlog10_hs_sizenum_orbitals
0planted_solution_000311.73408731
1planted_solution_000936.72557969
2planted_solution_000437.61989570
3planted_solution_00086.60292814
4planted_solution_001111.73408731
5planted_solution_00056.95511114
6planted_solution_000236.72557969
7planted_solution_00066.60292814
8planted_solution_001011.54724430
9planted_solution_00016.60292814
10planted_solution_000711.73408731
\n", + "
" + ], + "text/plain": [ + " prob_name_wo_uuid log10_hs_size num_orbitals\n", + "0 planted_solution_0003 11.734087 31\n", + "1 planted_solution_0009 36.725579 69\n", + "2 planted_solution_0004 37.619895 70\n", + "3 planted_solution_0008 6.602928 14\n", + "4 planted_solution_0011 11.734087 31\n", + "5 planted_solution_0005 6.955111 14\n", + "6 planted_solution_0002 36.725579 69\n", + "7 planted_solution_0006 6.602928 14\n", + "8 planted_solution_0010 11.547244 30\n", + "9 planted_solution_0001 6.602928 14\n", + "10 planted_solution_0007 11.734087 31" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "metadata[['prob_name_wo_uuid', 'log10_hs_size', 'num_orbitals']]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Path to MPSs: ../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_006_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_007_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_008_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_009_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_010_ket_optimized\n", + "../data/data_storage/planted_solution_0003.70f02aa9-7e8f-481c-a173-bf314a229153/mps_storage/dmrg_loop_011_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_006_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_007_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_008_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_009_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_010_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_011_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_012_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_013_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_014_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_015_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_016_ket_optimized\n", + "../data/data_storage/planted_solution_0009.8f2c4e3d-0d08-4bea-aa99-c495e953a60f/mps_storage/dmrg_loop_017_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_006_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_007_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_008_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_009_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_010_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_011_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_012_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_013_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_014_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_015_ket_optimized\n", + "../data/data_storage/planted_solution_0004.7e048638-8291-4fb5-9676-e25c4fe5e34a/mps_storage/dmrg_loop_016_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0008.815c4ddf-b6e6-4357-97da-c27898e85e90\n", + "../data/data_storage/planted_solution_0008.815c4ddf-b6e6-4357-97da-c27898e85e90/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0008.815c4ddf-b6e6-4357-97da-c27898e85e90/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0008.815c4ddf-b6e6-4357-97da-c27898e85e90/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0008.815c4ddf-b6e6-4357-97da-c27898e85e90/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0008.815c4ddf-b6e6-4357-97da-c27898e85e90/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0008.815c4ddf-b6e6-4357-97da-c27898e85e90/mps_storage/dmrg_loop_006_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_006_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_007_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_008_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_009_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_010_ket_optimized\n", + "../data/data_storage/planted_solution_0011.cabf5c61-6d4d-4019-9681-0b21a4e13b04/mps_storage/dmrg_loop_011_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0005.a3398364-0b77-461a-8b8a-ca3275ca0f49\n", + "../data/data_storage/planted_solution_0005.a3398364-0b77-461a-8b8a-ca3275ca0f49/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0005.a3398364-0b77-461a-8b8a-ca3275ca0f49/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0005.a3398364-0b77-461a-8b8a-ca3275ca0f49/mps_storage/dmrg_loop_003_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_006_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_007_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_008_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_009_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_010_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_011_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_012_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_013_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_014_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_015_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_016_ket_optimized\n", + "../data/data_storage/planted_solution_0002.aa45f868-b49c-49da-858a-c00a6ebef57e/mps_storage/dmrg_loop_017_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_006_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_007_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_008_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_009_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_010_ket_optimized\n", + "../data/data_storage/planted_solution_0006.baa43bb7-6cef-40c0-b8eb-4e1276f271f4/mps_storage/dmrg_loop_011_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0010.9005cc91-5b42-418d-8071-39b894b11884\n", + "../data/data_storage/planted_solution_0010.9005cc91-5b42-418d-8071-39b894b11884/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0010.9005cc91-5b42-418d-8071-39b894b11884/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0010.9005cc91-5b42-418d-8071-39b894b11884/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0010.9005cc91-5b42-418d-8071-39b894b11884/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0010.9005cc91-5b42-418d-8071-39b894b11884/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0010.9005cc91-5b42-418d-8071-39b894b11884/mps_storage/dmrg_loop_006_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_006_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_007_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_008_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_009_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_010_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_011_ket_optimized\n", + "../data/data_storage/planted_solution_0001.9086eb16-80c7-4aab-9c9f-aefd1ac41d0f/mps_storage/dmrg_loop_012_ket_optimized\n", + "Path to MPSs: ../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_001_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_002_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_003_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_004_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_005_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_006_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_007_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_008_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_009_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_010_ket_optimized\n", + "../data/data_storage/planted_solution_0007.f972a8d3-92fe-40cd-85b9-6d4ac3182506/mps_storage/dmrg_loop_011_ket_optimized\n" + ] + } + ], + "source": [ + "overlap_data = []\n", + "for index, row in metadata.iterrows():\n", + "\n", + " n_electrons = int(row[\"num_electrons\"])\n", + " spin = int(row[\"multiplicity\"]) - 1\n", + " n_cas = int(row[\"num_orbitals\"])\n", + "\n", + " full_path_to_solution = row['solution_dir']\n", + " print(f'Path to MPSs: {full_path_to_solution}')\n", + " \n", + " with h5py.File(full_path_to_solution/'dmrg_results.hdf5', 'r') as f:\n", + " loop_bd_info = {} \n", + " for k in f.keys():\n", + " if 'dmrg_loop_' in k:\n", + " loop_num = int(k.split('_')[-1])\n", + " max_bd = np.max(np.array(f[k]['dmrg_parameters']['sweep_schedule_bond_dims']))\n", + " loop_bd_info[loop_num] = max_bd\n", + "\n", + " n_loops = len(loop_bd_info)\n", + "\n", + " for loop in range(1, n_loops + 1):\n", + "\n", + " driver = DMRGDriver(scratch=\"./tmp\", symm_type=SymmetryTypes.SU2, n_threads=4)\n", + " driver.initialize_system(\n", + " n_sites=int(n_cas),\n", + " n_elec=int(n_electrons),\n", + " spin=int(spin),\n", + " )\n", + "\n", + " if loop > 9:\n", + " full_dir = full_path_to_solution/'mps_storage'/f'dmrg_loop_0{loop}_ket_optimized'\n", + " else:\n", + " full_dir = full_path_to_solution/'mps_storage'/f'dmrg_loop_00{loop}_ket_optimized'\n", + "\n", + " print(full_dir)\n", + "\n", + " assert os.path.isfile(full_dir/'mps_info.bin')\n", + "\n", + " ket = load_mps(full_dir)\n", + " #bd = ket.info.bond_dim # may not display the correct value\n", + " bd = loop_bd_info[loop]\n", + "\n", + " coeff, csf = max_det_coeff(driver, ket, cutoff=0.0005)\n", + " #zcsf = expand_csf(driver, csf, \n", + " # ne=int(n_electrons), \n", + " # no=int(n_cas), spin=int(spin))\n", + " #dets, coeffs = driver.get_csf_coefficients(zcsf, cutoff=1e-6, iprint=0)\n", + "\n", + "\n", + " overlap_data.append({'prob_name_wo_uuid' : row['prob_name_wo_uuid'],\n", + " 'loop' : loop,\n", + " 'num_orbitals' : row['num_orbitals'], \n", + " 'num_electrons' : row['num_electrons'], \n", + " 'bond_dimension' : bd,\n", + " 'hf_coeff' : np.abs(coeff), \n", + " 'csf' : csf, 'n_dets' : None})\n", + " # 'n_dets' : len(dets), })\n", + " #'z_s1' : z_s1 })\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
prob_name_wo_uuidloopnum_orbitalsnum_electronsbond_dimensionhf_coeffcsfn_dets
0planted_solution_00031315060.976323[0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ...None
1planted_solution_00032315070.977222[0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ...None
2planted_solution_00033315080.977415[0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ...None
3planted_solution_00034315090.976903[0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ...None
4planted_solution_000353150100.976597[0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ...None
\n", + "
" + ], + "text/plain": [ + " prob_name_wo_uuid loop num_orbitals num_electrons bond_dimension \\\n", + "0 planted_solution_0003 1 31 50 6 \n", + "1 planted_solution_0003 2 31 50 7 \n", + "2 planted_solution_0003 3 31 50 8 \n", + "3 planted_solution_0003 4 31 50 9 \n", + "4 planted_solution_0003 5 31 50 10 \n", + "\n", + " hf_coeff csf n_dets \n", + "0 0.976323 [0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ... None \n", + "1 0.977222 [0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ... None \n", + "2 0.977415 [0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ... None \n", + "3 0.976903 [0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ... None \n", + "4 0.976597 [0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ... None " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "overlaps = pd.DataFrame(overlap_data)\n", + "#overlaps = overlaps.join(metadata_.set_index('task_uuid'), on='task_uuid', how='left')\n", + "overlaps.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['prob_name_wo_uuid', 'loop', 'num_orbitals', 'num_electrons',\n", + " 'bond_dimension', 'hf_coeff', 'csf', 'n_dets'],\n", + " dtype='object')" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#overlaps.shape\n", + "overlaps.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array(['planted_solution_0003', 'planted_solution_0009',\n", + " 'planted_solution_0004', 'planted_solution_0008',\n", + " 'planted_solution_0011', 'planted_solution_0005',\n", + " 'planted_solution_0002', 'planted_solution_0006',\n", + " 'planted_solution_0010', 'planted_solution_0001',\n", + " 'planted_solution_0007'], dtype=object)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "overlaps.prob_name_wo_uuid.unique()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(6, 2, figsize=(5, 15))\n", + "ax_ = ax.flatten()\n", + "index = 0\n", + "for id_, group_ in overlaps.groupby('prob_name_wo_uuid'):\n", + " bd = group_['bond_dimension'].to_numpy()\n", + " abs_hf_coeff = group_['hf_coeff'].to_numpy()\n", + " p = np.argsort(bd)\n", + " no_tag = group_[\"num_orbitals\"].unique()[0]\n", + " ne_tag = group_['num_electrons'].unique()[0]\n", + " ax_[index].plot(bd[p], abs_hf_coeff[p], '^--')\n", + " ax_[index].set_xlabel('bond dim.')\n", + " ax_[index].tick_params(axis='x', labelrotation=45)\n", + " ax_[index].set_ylabel(r'$|c_0|$')\n", + " ax_[index].set_yscale('log')\n", + " ax_[index].set_title(f'{id_.split(\"_\")[-1]} ({int(no_tag)}o, {int(ne_tag)}e)')\n", + " index += 1\n", + "\n", + "fig.tight_layout()\n", + "plt.savefig('overlaps.png', dpi=300)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
loopnum_orbitalsnum_electronsbond_dimensionhf_coeff
prob_name_wo_uuid
planted_solution_0001121418240.708597
planted_solution_0002176990410.225133
planted_solution_0003113150210.977415
planted_solution_0004167090370.968532
planted_solution_00053141680.998537
\n", + "
" + ], + "text/plain": [ + " loop num_orbitals num_electrons bond_dimension \\\n", + "prob_name_wo_uuid \n", + "planted_solution_0001 12 14 18 24 \n", + "planted_solution_0002 17 69 90 41 \n", + "planted_solution_0003 11 31 50 21 \n", + "planted_solution_0004 16 70 90 37 \n", + "planted_solution_0005 3 14 16 8 \n", + "\n", + " hf_coeff \n", + "prob_name_wo_uuid \n", + "planted_solution_0001 0.708597 \n", + "planted_solution_0002 0.225133 \n", + "planted_solution_0003 0.977415 \n", + "planted_solution_0004 0.968532 \n", + "planted_solution_0005 0.998537 " + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "overlaps_summary = overlaps.groupby('prob_name_wo_uuid').max('loop')\n", + "overlaps_summary.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "#overlaps_summary = overlaps_summary.join(metadata[['prob_name_wo_uuid', 'instance_data_object_url']].set_index('prob_name_wo_uuid'), on='prob_name_wo_uuid', how='left')\n", + "overlaps_summary = overlaps_summary.join(metadata[['prob_name_wo_uuid', 'task_uuid']].set_index('prob_name_wo_uuid'), on='prob_name_wo_uuid', how='left')" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "overlaps_summary.rename(columns={'hf_coeff' : 'overlap'}, inplace=True)\n", + "overlaps_summary[['overlap', 'task_uuid']].to_csv('overlaps.csv', index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "darpa", + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/scripts/overlaps.csv b/scripts/overlaps.csv index 2e31d2d..ae0d2d7 100644 --- a/scripts/overlaps.csv +++ b/scripts/overlaps.csv @@ -1,4 +1,12 @@ -task_uuid,overlap -be3812d3-5975-4736-8a23-96d64e50e66a,0.7085974535652702 -472bbfb1-c081-4df6-b966-32ce1194ab8c,0.9774145158534091 -a41a284c-7baa-438e-9323-532091c7a78f,0.9985372277228635 +overlap,task_uuid +0.7085974535652702,be3812d3-5975-4736-8a23-96d64e50e66a +0.22513330252311292,0deae366-42de-4081-914d-db85c6b47168 +0.9774145158534091,472bbfb1-c081-4df6-b966-32ce1194ab8c +0.9685316094601323,c9809448-2f3d-40d4-858d-6288a4703af4 +0.9985372277228635,a41a284c-7baa-438e-9323-532091c7a78f +0.949143431782712,d28f02ba-d43f-4df9-a01a-f1e8ac326e08 +0.9183533021847063,d3c058ec-9b13-4a9a-aba0-d3f19091c47b +0.8117853524308283,af56de36-35aa-44b9-8eb7-b9c1e8f7d0f3 +0.9590201342647006,8f373cb0-952d-48c6-a871-8a10e52e7c19 +0.9958029416443275,7cc1ed5c-0dcb-4315-9e51-2ae94b5cdd02 +0.9951522181318971,0021e256-8e13-42db-839d-e9155e8af82c diff --git a/src/qb_gsee_benchmark/cas_utils.py b/src/qb_gsee_benchmark/cas_utils.py new file mode 100644 index 0000000..eec53df --- /dev/null +++ b/src/qb_gsee_benchmark/cas_utils.py @@ -0,0 +1,14 @@ +import numpy as np +from scipy.special import comb + +def log_hilbert_space_size(no: int, ne: int, mult: int) -> float: + '''Compute log10 of the Hilbert space size assuming Sz + is conserved. + ''' + + nalpha = (ne + mult - 1) // 2 + nbeta = (ne - mult + 1) // 2 + log_hs = np.log10(comb(no, nalpha, exact=False)) + np.log10( + comb(no, nbeta, exact=False) + ) + return log_hs \ No newline at end of file diff --git a/src/qb_gsee_benchmark/dmrg_utils.py b/src/qb_gsee_benchmark/dmrg_utils.py new file mode 100644 index 0000000..8015c3d --- /dev/null +++ b/src/qb_gsee_benchmark/dmrg_utils.py @@ -0,0 +1,72 @@ +import block2 +from block2 import SU2 +from pyblock2.driver.core import DMRGDriver, SymmetryTypes +from typing import Union, List, Tuple +import numpy as np +from pyblock2 import tools +from copy import deepcopy + + +def max_det_coeff( + driver: DMRGDriver, ket: Union[block2.sz.MPS, block2.su2.MPS], cutoff: float = 0.001 +) -> Tuple[float, List[int]]: + """Get the abs weight of the dominant CSF in a DMRG solution and + a corresponding occupation number representation. + + Args: + driver: Block2 DMRG driver initialized with the parameters + used when generating the solution. + ket: Block2 MPS ket. + cuttoff: positive floating point cutoff for the minimum expansion + coefficient value sampled from MPS. + Returns: a tuple of the maximum absolute CSF weight and its occupation + number representation. + """ + + csfs, coeffs = driver.get_csf_coefficients(ket, cutoff=cutoff, iprint=0) + abs_coeffs = np.abs(coeffs) + return coeffs[np.argmax(abs_coeffs)], csfs[np.argmax(abs_coeffs)] + + +def load_mps(directory) -> Union[block2.sz.MPS, block2.su2.MPS]: + """Given a directory where Block2 MPS was save produces an Block2 + MPS object; a driver object should be initialized to use this function. + """ + + tools.init(SU2) + mps = tools.loadMPSfromDir(mps_info=None, mpsSaveDir=directory) + return mps + + +def expand_csf( + driver: DMRGDriver, csf: List, ne: int, no: int, spin: int +) -> block2.sz.MPS: + """Given a CSF produced by driver.get_csf_coefficients + creates a *normalized* SZ adapted MPS out of it. + + Args: + driver: Block2 DMRG driver initialized with the parameters + used when generating the solution. + csf: Orbital occupation list for the CSF using Block2 notation. + Returns: A normalized SZ adapted MPS. + """ + + mps_csf = driver.get_mps_from_csf_coefficients([csf], [1.0], tag="CSF", dot=1) + zket = driver.mps_change_to_sz(mps_csf, "ZCSF", sz=spin) + + driver.symm_type = SymmetryTypes.SZ + driver.initialize_system( + n_sites=no, + n_elec=ne, + spin=spin, + ) + + impo = driver.get_identity_mpo() + ovlp_csf = driver.expectation(zket, impo, zket) + + zket.load_tensor(zket.center) + zket.tensors[zket.center].data = zket.tensors[zket.center].data / ovlp_csf**0.5 + zket.save_tensor(zket.center) + assert abs(driver.expectation(zket, impo, zket) - 1) < 1e-10 + + return zket From 428b14cc0485d1eb1afbfb7090f2b1196c0eaf62 Mon Sep 17 00:00:00 2001 From: Alexander Kunitsa <28026247+aakunitsa@users.noreply.github.com> Date: Wed, 4 Dec 2024 12:23:34 -0500 Subject: [PATCH 02/25] updated overlaps with the values for mn_mono --- scripts/overlaps.csv | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/scripts/overlaps.csv b/scripts/overlaps.csv index ae0d2d7..35b8d69 100644 --- a/scripts/overlaps.csv +++ b/scripts/overlaps.csv @@ -10,3 +10,11 @@ overlap,task_uuid 0.9590201342647006,8f373cb0-952d-48c6-a871-8a10e52e7c19 0.9958029416443275,7cc1ed5c-0dcb-4315-9e51-2ae94b5cdd02 0.9951522181318971,0021e256-8e13-42db-839d-e9155e8af82c +0.2498975652988538,a9c90f98-6557-44d2-9ca0-0c9122f4080c +0.1561587908258567,a16168e2-98cd-430d-a180-84f64b4d5e75 +0.4308955197607803,1ade03f3-06b1-4e95-b271-fea5a6343829 +0.2537188887662813,6e617348-d0b3-4b6d-9923-ea54ba5cf751 +0.2919660904194511,6c39d3a7-c71a-4049-a8c7-3a3a4b61d8da +0.6181363782025164,de3ea361-c2d3-4ab6-add4-ccd43cea6aa8 +0.2121397979087371,590c2f0b-964b-4d09-96ad-101a9be59cab +0.3962841546152906,ff0da1e2-2c76-4589-aefa-c13bb1a1ef8f From e8fc6ae891fbc76066c9d95c0273297a7340f23d Mon Sep 17 00:00:00 2001 From: Alexander Kunitsa <28026247+aakunitsa@users.noreply.github.com> Date: Thu, 5 Dec 2024 16:09:54 -0500 Subject: [PATCH 03/25] latest set of overlaps --- scripts/overlaps.csv | 166 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 148 insertions(+), 18 deletions(-) diff --git a/scripts/overlaps.csv b/scripts/overlaps.csv index 35b8d69..255c0ac 100644 --- a/scripts/overlaps.csv +++ b/scripts/overlaps.csv @@ -1,20 +1,150 @@ overlap,task_uuid -0.7085974535652702,be3812d3-5975-4736-8a23-96d64e50e66a -0.22513330252311292,0deae366-42de-4081-914d-db85c6b47168 -0.9774145158534091,472bbfb1-c081-4df6-b966-32ce1194ab8c -0.9685316094601323,c9809448-2f3d-40d4-858d-6288a4703af4 -0.9985372277228635,a41a284c-7baa-438e-9323-532091c7a78f -0.949143431782712,d28f02ba-d43f-4df9-a01a-f1e8ac326e08 -0.9183533021847063,d3c058ec-9b13-4a9a-aba0-d3f19091c47b -0.8117853524308283,af56de36-35aa-44b9-8eb7-b9c1e8f7d0f3 -0.9590201342647006,8f373cb0-952d-48c6-a871-8a10e52e7c19 -0.9958029416443275,7cc1ed5c-0dcb-4315-9e51-2ae94b5cdd02 -0.9951522181318971,0021e256-8e13-42db-839d-e9155e8af82c -0.2498975652988538,a9c90f98-6557-44d2-9ca0-0c9122f4080c -0.1561587908258567,a16168e2-98cd-430d-a180-84f64b4d5e75 -0.4308955197607803,1ade03f3-06b1-4e95-b271-fea5a6343829 -0.2537188887662813,6e617348-d0b3-4b6d-9923-ea54ba5cf751 +0.6181363888375566,de3ea361-c2d3-4ab6-add4-ccd43cea6aa8 0.2919660904194511,6c39d3a7-c71a-4049-a8c7-3a3a4b61d8da -0.6181363782025164,de3ea361-c2d3-4ab6-add4-ccd43cea6aa8 -0.2121397979087371,590c2f0b-964b-4d09-96ad-101a9be59cab -0.3962841546152906,ff0da1e2-2c76-4589-aefa-c13bb1a1ef8f +0.4308954760045241,1ade03f3-06b1-4e95-b271-fea5a6343829 +0.39628415461529065,ff0da1e2-2c76-4589-aefa-c13bb1a1ef8f +0.24982913007793,a9c90f98-6557-44d2-9ca0-0c9122f4080c +0.15615879082585676,a16168e2-98cd-430d-a180-84f64b4d5e75 +0.21213965342703758,590c2f0b-964b-4d09-96ad-101a9be59cab +0.2537174201523171,6e617348-d0b3-4b6d-9923-ea54ba5cf751 +0.540683412661287,fc3586af-0290-4a4a-81e1-422a1d331a09 +0.5316889578895321,7ecc9a42-2b18-4179-81ec-583598fa579b +0.5606054133761018,37e1f17b-384d-423d-860b-c75b9dcff951 +0.9755036392893192,472bbfb1-c081-4df6-b966-32ce1194ab8c +0.8258727805913333,5f5fee92-5821-4d38-a54a-d204660f205f +0.17439207902567544,1c7f5399-8982-4daf-81a5-7cef4e4588cc +0.43312514607269575,828c931b-4d5a-486e-ba26-abb293c1ccef +0.5850377384233345,0667179a-19eb-44b9-a544-dae8793fdc3f +0.54990006323591,ae315bef-f3c6-4c84-93c5-0d8ab510ece3 +0.8366211129242754,b8344eb5-f574-4198-b917-8312240ba288 +0.940263183195416,8f373cb0-952d-48c6-a871-8a10e52e7c19 +0.9524650450733059,afdc2f74-eb52-41ae-b72a-30e5a4c07013 +0.9520713745354795,543e2ed4-a12d-495b-a246-1e4d905ad4a3 +0.8084535204674654,4fb7e994-8e7a-4acd-86d4-bb52db824cfc +0.07081546533039988,f96de7fe-5c88-4083-8c48-72bc094cccfd +0.8050459672499516,620e9ff4-07bf-4767-9237-d39aa659b8e5 +0.8072708898198815,ca6f7678-0952-4fe4-83fe-c4455a682132 +0.3952231578105606,10119019-eea2-45c9-a748-e206780c4235 +0.9682466675887548,78d5e5ba-0b2c-4cfe-92c5-f1c749150015 +0.9549253340967099,80043b93-039c-4d5a-abcb-84b8f25f7abb +0.194612513043793,0485949f-722c-49ee-a748-eec54801f021 +0.9600998945527054,b80345ff-5df9-4fb3-86ab-0a25188b296d +0.6338151480452492,15a25e30-cba9-4f63-80a6-ef95a8c79d41 +0.49298462985270486,26423f2e-e3e1-4bbb-b2ff-52bdae87d65b +0.5196648658377835,9757b7c2-d420-4ebb-8da7-38238951a5ca +0.5990760161439896,2761e36e-f001-42af-8086-f507b5643ec8 +0.6943818151002712,b1352b0c-aa96-4f58-a0e2-356d3c43c8a1 +0.9126292828430185,b59bd259-4941-4cec-bca5-e2795c35d8e0 +0.8722191236884672,9e3c577f-a25d-42f5-a809-61dfb63a52de +0.9160043994968375,daa86ad6-bda9-4d47-a50d-4ec34801bd82 +0.966306313762271,c9809448-2f3d-40d4-858d-6288a4703af4 +0.32044239122371965,615c9d78-2b84-4c7b-ab6b-ba05b188f50a +0.29126122107466923,a091c1a1-bde2-4a83-bf58-5010f7a8e1d4 +0.439201673227498,c7cd47fa-1bbd-4859-a0c8-3fd5c287c6db +0.24475328418994552,84243fc5-4284-4393-bb1d-b73bf600eb26 +0.7538015280422038,f2f09d9f-8328-4d4a-ba91-089f9e56bf0d +0.14468775304671863,3d5186f9-82b3-4de0-9bc1-242d7bdb678a +0.7533200089763514,ec0baf59-05f5-49df-b5e5-8f887d822a10 +0.8116349203731124,af56de36-35aa-44b9-8eb7-b9c1e8f7d0f3 +0.9947672670288688,0021e256-8e13-42db-839d-e9155e8af82c +0.9737479975344326,402d5237-16a3-4eb8-8bd4-5dcf2cb14c36 +0.9790459758772545,b4e88a1e-f05f-4ff7-bd91-b24a5073c6ca +0.8081000294453841,85a3a8d6-f2c7-458c-bbc3-25fd76d9afc0 +0.43394730545128957,e0101b06-dfd6-4caa-8580-a9815b225204 +0.9985217923042187,a41a284c-7baa-438e-9323-532091c7a78f +0.9182236198867316,92917287-d937-410c-bb70-c1f34224fab7 +0.9350859411652318,13b4bdcc-1cef-419a-92b1-156febff71d4 +0.9326549491092637,d15db194-aa2d-4de9-8f86-fcffeb82f38b +0.41525161907828756,7f0518e8-e2c8-4912-8268-4de4cd504084 +0.17953444246206746,0f5171c4-cf55-4a82-99a2-c72edebce9c9 +0.5933821739928463,bd44e482-057d-42c3-a052-cbd952fa8025 +0.7280248475402965,fea4b4a2-64a1-45c3-a760-83aec702bdca +0.26409925337332185,63c089b2-1940-4301-89d6-93ecc98c07f1 +0.5324663637234944,ff159145-fd97-486b-bf16-fc766b362ea3 +0.7519941708934933,443371ce-c80d-450d-b281-ac1c4d5ecc4d +0.8651491828996847,f936469c-1d1e-4295-a006-84a778c1714c +0.414631236614263,02588640-a5ae-48e6-b28b-f6759886ab70 +0.38816946501140825,7ea61c79-c0e5-453b-8fd0-b176cb8821a7 +0.31489583761613127,a92f6594-5ccc-4385-9cb5-8c21b4407dcf +0.8067346872450737,fb87d637-aaab-4e8f-8898-4ecca8bd0fe0 +0.27610594409157496,96c6a0d7-8a1e-4189-a934-833b80ade346 +0.9353443535960312,dc1da839-0ccc-434c-bf9c-a3874ffc3b1c +0.49584531708385704,6d0f8edd-507f-43d5-9960-9ad49532ee42 +0.2997358456016284,ab61c91a-68ea-401f-a3ad-392e83ee802e +0.2997344110026041,0c023ffe-8453-4f5f-b29e-7863589fb191 +0.7290141657085581,77c3a92c-066c-4043-a4a1-5e8324014d0b +0.8146411522529097,1094e868-f84e-403b-9b54-50802b1cdb60 +0.5847690629045638,9fa4fc3a-b0b9-4eaa-99ee-0469ae5a511d +0.0805458973019966,0deae366-42de-4081-914d-db85c6b47168 +0.8407374469390434,b24b71b9-971a-4aca-9fc0-7198d16ca9ed +0.20384123983480526,e604a906-55fa-4b3f-bf17-c24a30312b84 +0.8956228269751177,f4b120e9-acd0-4c7c-89e2-cc082f52f5cf +0.4464283701697618,0f0c8766-4bf5-4c1e-991a-9dafe9bc8f27 +0.5033481146628889,338f4b6e-775c-413b-a508-9132659ebbc3 +0.9427784348715271,d28f02ba-d43f-4df9-a01a-f1e8ac326e08 +0.670974499781749,c01649e2-8c5c-4827-a037-1ede2159e558 +0.08503908021492913,214bb702-d7bc-4141-8cf3-f6979ba0f67a +0.665315136579475,35e4c771-0f4f-4413-b42f-132f1e606cb0 +0.3459503609590604,084acde0-d1c7-4721-aa45-acb4832e0998 +0.07418520922900246,e61df0de-0a97-4204-9fb9-3995c30d7999 +0.36273484955600765,23a06c81-be81-4f88-98ab-9e7030c909ef +0.5661915904148612,85743547-31ba-48ff-b854-220e4b9b620f +0.3524084521537975,ae328238-7f54-43e2-bf9a-01c60563e578 +0.8416336539703874,e7d3b8bd-ff6c-44f6-8a9e-b9b75396cee0 +0.8475681043672622,aaa24a30-ade6-44a6-b6aa-51bf54c31eef +0.844913472095655,410cd417-988a-4f7f-99ad-93dda7eacdcb +0.8254151960665101,5f0ac7ac-1dcc-46a6-bfa0-6e76c73a0bdd +0.8620846246828182,6a16e45d-545d-4827-9617-3c83fb323a97 +0.8271832380669065,8fa0ddcf-9b98-4144-8250-522f38c28b02 +0.9877149438611187,752966e5-7de7-4506-82ae-6b22cd54b1c1 +0.9853520101652548,64122cc6-e1bb-4c11-8d00-2189d27194f1 +0.9851292014049342,f9bdbb3b-91b6-43f3-93ca-bef1e10d3835 +0.722024793482085,94fc2317-29af-43a1-aaec-dade9850ca27 +0.15296971162158293,fa8e83f2-cec5-4609-9b77-d713608a6b53 +0.6828225585628203,3fb371ad-c738-40ae-b9ae-80e5bce8f2ac +0.5372570179178392,d58cb72b-e144-4164-aec0-309aaef6394c +0.501414942630468,ed09e1bf-40f3-4bf0-b9c7-7bb1990c5cae +0.995549158337574,7cc1ed5c-0dcb-4315-9e51-2ae94b5cdd02 +0.7657194114884147,240f7830-f4e1-4301-b0af-ab8936851796 +0.539794703346677,50de76ad-110a-4c09-836a-64cc60c87f9a +0.7688511646890079,5e1dcd34-1373-4f34-b9df-d738a8cf4db6 +0.8826098904124169,5d85532e-9116-48a1-9810-7925c9ed9c57 +0.2823170976537744,35b59fd4-e046-4d69-ba52-4b94a7777ac3 +0.4596711644685225,88a6b9fd-e159-4059-9ee5-ba718fd624dc +0.32519857794234475,cca08104-f5f6-407f-9c62-faadc8f29bec +0.5118380343565483,8aa559b0-3aae-4850-a2d7-14e037ce26c0 +0.9133588675756205,f0ee8150-86e2-4f9e-ae35-95af38f3c69e +0.6829490747901606,be3812d3-5975-4736-8a23-96d64e50e66a +0.9571165455651252,da831b60-89ce-4c01-96f9-c9f8a4512aab +0.35433991967150064,a2f9649f-0f47-4a5d-a6a7-b0bebc848797 +0.9499571410599129,01ec60f7-d38a-4c33-a498-659a388e10ee +0.5581659505575303,84aa9e2d-18e6-4689-9274-28e89ef44080 +0.49970300255700767,109f95c5-8561-458c-8f41-72be596b87e6 +0.830411731352884,80d75334-b878-41ec-99a8-b21277f3df60 +0.6669074552720627,5e576716-0df8-4712-8f03-ea1ac3808e35 +0.841632388051623,4e395cc5-b5d2-4b82-95a2-1276262386c8 +0.6418701474873403,af399f2b-a4f8-4fec-aca2-7c126ed989a5 +0.6949648911764919,819ff18a-5aad-46df-83ef-bd209e44936b +0.7711012057791867,2cd76a23-0514-458a-b588-94e2d10564d3 +0.7602077309267771,c7049602-5460-4277-8148-d9c66012f8f0 +0.7729278587408023,289f5dfe-e6d5-48a3-a6ae-25088321d3c6 +0.533697347210007,24f12fad-130e-44fc-8b07-bc26c5a3d878 +0.6191154167740001,2eaee11d-c1a0-4d2b-b29b-a38e658572f2 +0.14744767129640698,6ca72d49-425b-43f3-96e7-4067bacd0596 +0.5113828950668766,b9c35349-927d-47d5-8e0c-e054bbf4e4e0 +0.1523729586675485,9eed79e4-b195-4474-b280-fe9166a7a241 +0.5121702922839056,666185aa-b65d-4f73-8846-ae9693388d9d +0.8671047512987239,fa3bc2a8-8067-4088-909a-2ddfa655ebfb +0.8289806716907081,8f39fc4f-91dc-4f67-ab5c-00e8ffc866c4 +0.8606915139302134,f0637f33-3c53-4f01-8cf7-cfd9c6f39a51 +0.9738115234937592,9d82f7d4-165d-4499-8add-361a770d1d44 +0.9944532530076432,29eecba9-3d4d-4672-8b19-475f53b2f1be +0.6144775268422011,886855d3-f1a7-4004-a736-417360e81d0a +0.5561545970692378,57830810-1133-4c19-9a19-30183dd86a9f +0.7972235466559661,5b8f4746-a08b-4ec5-92e2-ce55cc2fdb75 +0.5502039499812766,c63f5f9b-ee73-4887-949b-dd1e74c31874 +0.912256003155052,d3c058ec-9b13-4a9a-aba0-d3f19091c47b +0.34648417989028485,94db0c2c-89f6-4c3d-b886-a3a6a2bdad1d +0.3946385739338629,c5ef4702-fc8d-4168-b594-8d5872fdb523 +0.9679412297647962,a7e26b10-bd6b-457c-978e-9050f6529007 +0.8576347196150523,6ab8d16c-b8f3-4780-b278-dad81646ca8c From 49477762a8033e293af01ace454afb438c03ccca Mon Sep 17 00:00:00 2001 From: Max Radin Date: Fri, 6 Dec 2024 12:36:55 -0800 Subject: [PATCH 04/25] Initial implementation of physical resource estimates --- scripts/compute_all_LREs_script.py | 114 ++++++++++++++++++++++------- setup.cfg | 1 + 2 files changed, 87 insertions(+), 28 deletions(-) diff --git a/scripts/compute_all_LREs_script.py b/scripts/compute_all_LREs_script.py index d0bd861..e3889d2 100755 --- a/scripts/compute_all_LREs_script.py +++ b/scripts/compute_all_LREs_script.py @@ -30,10 +30,20 @@ import pandas as pd from pyLIQTR.utils.resource_analysis import estimate_resources +from qualtran.surface_code.algorithm_summary import AlgorithmSummary +from qualtran.surface_code.ccz2t_cost_model import ( + get_ccz2t_costs_from_grid_search, + iter_ccz2t_factories, +) from qb_gsee_benchmark.qre import get_df_qpe_circuit from qb_gsee_benchmark.utils import retrieve_fcidump_from_sftp + +class NoFactoriesFoundError(Exception): + pass + + logger = logging.getLogger() logger.setLevel(logging.INFO) console_handler = logging.StreamHandler() @@ -45,6 +55,30 @@ logger.addHandler(h) +def get_physical_cost( + num_logical_qubits: int, + num_T_gates: int, + hardware_failure_tolerance_per_shot: float, + n_factories: int, + physical_error_rate: float, +): + n_magic = AlgorithmSummary(t_gates=num_T_gates) + try: + best_cost, best_factory, best_data_block = get_ccz2t_costs_from_grid_search( + n_magic=n_magic, + n_algo_qubits=num_logical_qubits, + error_budget=hardware_failure_tolerance_per_shot, + phys_err=physical_error_rate, + factory_iter=iter_ccz2t_factories(n_factories=n_factories), + cost_function=(lambda pc: pc.duration_hr), + ) + return best_cost.duration_hr * 60 * 60, best_cost.footprint + except TypeError: + raise NoFactoriesFoundError( + f"No factories found that meet the performance requirements." + ) + + def get_lqre( problem_instance: dict, username: str, ppk_path: str, config: dict ) -> dict[str, Any]: @@ -153,37 +187,61 @@ def get_lqre( ).total_seconds() logging.info(f"Resource estimation time (seconds): {LRE_calc_time}") - solution_data.append( - { - "task_uuid": task["task_uuid"], - "error_bound": error_tolerance, - "confidence_level": failure_tolerance, - "quantum_resources": { - "logical": { - "num_logical_qubits": logical_resources["LogicalQubits"], - "num_T_gates_per_shot": logical_resources["T"], - "num_shots": math.ceil(num_shots), - "hardware_failure_tolerance_per_shot": hardware_failure_tolerance_per_shot, - } + task_solution_data = { + "task_uuid": task["task_uuid"], + "error_bound": error_tolerance, + "confidence_level": failure_tolerance, + "quantum_resources": { + "logical": { + "num_logical_qubits": logical_resources["LogicalQubits"], + "num_T_gates_per_shot": logical_resources["T"], + "num_shots": math.ceil(num_shots), + "hardware_failure_tolerance_per_shot": hardware_failure_tolerance_per_shot, + } + }, + "run_time": { + "preprocessing_time": { + "wall_clock_start_time": circuit_generation_start_time.strftime( + "%Y-%m-%dT%H:%M:%S.%f" + ) + + "Z", + "wall_clock_stop_time": circuit_generation_end_time.strftime( + "%Y-%m-%dT%H:%M:%S.%f" + ) + + "Z", + "seconds": ( + circuit_generation_end_time - circuit_generation_start_time + ).total_seconds(), }, - "run_time": { - "preprocessing_time": { - "wall_clock_start_time": circuit_generation_start_time.strftime( - "%Y-%m-%dT%H:%M:%S.%f" - ) - + "Z", - "wall_clock_stop_time": circuit_generation_end_time.strftime( - "%Y-%m-%dT%H:%M:%S.%f" - ) - + "Z", - "seconds": ( - circuit_generation_end_time - - circuit_generation_start_time - ).total_seconds(), - } + }, + } + + try: + algorithm_runtime_seconds, num_physical_qubits = get_physical_cost( + num_logical_qubits=logical_resources["LogicalQubits"], + num_T_gates=logical_resources["T"], + hardware_failure_tolerance_per_shot=hardware_failure_tolerance_per_shot, + n_factories=config["hardware_parameters"]["n_factories"], + physical_error_rate=config["hardware_parameters"][ + "physical_error_rate" + ], + ) + task_solution_data["run_time"]["algorithm_run_time"] = ( + { + "seconds": algorithm_runtime_seconds, }, + ) + task_solution_data["run_time"]["overall_time"] = { + "seconds": ( + circuit_generation_end_time - circuit_generation_start_time + ).total_seconds() + + algorithm_runtime_seconds } - ) + except NoFactoriesFoundError: + logging.info( + f"No factories found that meet the performance requirements. Skipping physical cost estimation." + ) + solution_data.append(task_solution_data) solution_uuid = str(uuid4()) current_time = datetime.datetime.now(datetime.timezone.utc) diff --git a/setup.cfg b/setup.cfg index db60479..3826330 100644 --- a/setup.cfg +++ b/setup.cfg @@ -25,6 +25,7 @@ python_requires = >=3.8 install_requires = pyLIQTR>=1.2.0 + qualtran==0.2.0 pyscf openfermion openfermionpyscf From d9830f9902234fc36c4064526397823db7604942 Mon Sep 17 00:00:00 2001 From: Max Radin Date: Fri, 6 Dec 2024 14:19:27 -0800 Subject: [PATCH 05/25] Updating config --- scripts/LRE_config.json | 7 ++++++- scripts/compute_all_LREs_script.py | 7 ++++++- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/scripts/LRE_config.json b/scripts/LRE_config.json index 7da759d..9181a2a 100644 --- a/scripts/LRE_config.json +++ b/scripts/LRE_config.json @@ -3,9 +3,14 @@ "algorithm_parameters": { "overlap": 0.8, "df_threshold": 1e-3, - "max_orbitals": 32 + "max_orbitals": 37 }, "algorithm_description": "Double factorized QPE resource estimates based on methodology of arXiv:2406.06335. Note that the truncation error is not included in the error bounds and that the SCF compute time is not included in the preprocessing time. Also note that unlike arXiv:2406.06335, the ground-state overlaps are not computed from DMRG but instead set to a nominal value.", + "quantum_hardware_parameters": { + "num_factories": 4, + "physical_error_rate": 1e-3 + }, + "quantum_hardware_description": "foo", "contact_info": [ { "name": "Max Radin", diff --git a/scripts/compute_all_LREs_script.py b/scripts/compute_all_LREs_script.py index e3889d2..160b797 100755 --- a/scripts/compute_all_LREs_script.py +++ b/scripts/compute_all_LREs_script.py @@ -217,15 +217,20 @@ def get_lqre( } try: + physical_resource_estimation_start = datetime.datetime.now() algorithm_runtime_seconds, num_physical_qubits = get_physical_cost( num_logical_qubits=logical_resources["LogicalQubits"], num_T_gates=logical_resources["T"], hardware_failure_tolerance_per_shot=hardware_failure_tolerance_per_shot, - n_factories=config["hardware_parameters"]["n_factories"], + n_factories=config["hardware_parameters"]["num_factories"], physical_error_rate=config["hardware_parameters"][ "physical_error_rate" ], ) + physical_resource_estimation_end = datetime.datetime.now() + logging.info( + f"Physical resource estimation time: {(physical_resource_estimation_end - physical_resource_estimation_start).total_seconds()} seconds." + ) task_solution_data["run_time"]["algorithm_run_time"] = ( { "seconds": algorithm_runtime_seconds, From 733c194031a0eb66682fe1c016c746e1984f9e79 Mon Sep 17 00:00:00 2001 From: Max Radin Date: Fri, 6 Dec 2024 15:09:07 -0800 Subject: [PATCH 06/25] Renaming LRE to QRE --- README.md | 6 ++-- schemas/solution.schema.0.0.1.json | 10 +++++- scripts/{LRE_config.json => QRE_config.json} | 0 ...overlaps.json => QRE_config_overlaps.json} | 0 ...s_script.py => compute_all_QREs_script.py} | 32 ++++++++++++++----- 5 files changed, 36 insertions(+), 12 deletions(-) rename scripts/{LRE_config.json => QRE_config.json} (100%) rename scripts/{LRE_config_overlaps.json => QRE_config_overlaps.json} (100%) rename scripts/{compute_all_LREs_script.py => compute_all_QREs_script.py} (91%) diff --git a/README.md b/README.md index c087a71..f896aad 100644 --- a/README.md +++ b/README.md @@ -38,17 +38,17 @@ Contact the repository maintainers to get these. ### Generating Logical Quantum Resource Estimates -The [`scripts/compute_all_LREs_script.py`](scripts/compute_all_LREs_script.py) script can be used to generate LQREs. +The [`scripts/compute_all_QREs_script.py`](scripts/compute_all_QREs_script.py) script can be used to generate LQREs. In order to run this script, first ensure that the qb-gsee-benchmark package is installed as described above. Then, several files are required: * A PPK file containing a key to access the SFTP server that provides access to FCIDUMP files as described above. -* A configuration file similar to [`scripts/LRE_config.json`](scripts/LRE_config.json) or [`scripts/LRE_config.json`](scripts/LRE_config_overlaps.json) which specifies algorithm parameters, solver UUID, and other information. +* A configuration file similar to [`scripts/QRE_config.json`](scripts/QRE_config.json) or [`scripts/QRE_config.json`](scripts/QRE_config_overlaps.json) which specifies algorithm parameters, solver UUID, and other information. * If the `algorithm_parameters` object in the config file specifies a value for `overlap_csv`, then this CSV file must also be present. See for example [`scripts/overlaps.csv`](scripts/overlaps.csv) The paths to these files must be passed as arguments to the script, for example: ```bash -python compute_all_LREs_script.py -i ../problem_instances -o ../solution_files --LRE_config_file LRE_config.json --sftp_username darpa-qb --sftp_key_file path_to_ppk_file +python compute_all_QREs_script.py -i ../problem_instances -o ../solution_files --QRE_config_file QRE_config.json --sftp_username darpa-qb --sftp_key_file path_to_ppk_file ```