From 0de866fd9dec8a35ed9b6951cbcec2304125a23e Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Tue, 16 Jul 2024 09:34:16 +0100 Subject: [PATCH 01/32] Feature: add base qcvv framework --- cirq-superstaq/cirq_superstaq/__init__.py | 3 +- .../cirq_superstaq/qcvv/__init__.py | 13 + .../cirq_superstaq/qcvv/base_experiment.py | 413 ++++++++++++++++++ .../qcvv/base_experiment_test.py | 383 ++++++++++++++++ docs/source/apps/qcvv/qcvv.rst | 17 + docs/source/apps/qcvv/qcvv_css.ipynb | 235 ++++++++++ docs/source/cirq_superstaq.qcvv.rst | 21 + docs/source/index.rst | 3 +- 8 files changed, 1086 insertions(+), 2 deletions(-) create mode 100644 cirq-superstaq/cirq_superstaq/qcvv/__init__.py create mode 100644 cirq-superstaq/cirq_superstaq/qcvv/base_experiment.py create mode 100644 cirq-superstaq/cirq_superstaq/qcvv/base_experiment_test.py create mode 100644 docs/source/apps/qcvv/qcvv.rst create mode 100644 docs/source/apps/qcvv/qcvv_css.ipynb create mode 100644 docs/source/cirq_superstaq.qcvv.rst diff --git a/cirq-superstaq/cirq_superstaq/__init__.py b/cirq-superstaq/cirq_superstaq/__init__.py index 5b2aad57f..b8ae8659a 100644 --- a/cirq-superstaq/cirq_superstaq/__init__.py +++ b/cirq-superstaq/cirq_superstaq/__init__.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from cirq_superstaq import compiler_output, validation +from cirq_superstaq import compiler_output, qcvv, validation from cirq_superstaq._version import __version__ from cirq_superstaq.compiler_output import active_qubit_indices, measured_qubit_indices from cirq_superstaq.job import Job @@ -104,6 +104,7 @@ "compiler_output", "deserialize_circuits", "parallel_gates_operation", + "qcvv", "qubit_subspace_op", "qudit_swap_op", "serialize_circuits", diff --git a/cirq-superstaq/cirq_superstaq/qcvv/__init__.py b/cirq-superstaq/cirq_superstaq/qcvv/__init__.py new file mode 100644 index 000000000..b530814bd --- /dev/null +++ b/cirq-superstaq/cirq_superstaq/qcvv/__init__.py @@ -0,0 +1,13 @@ +# Copyright 2021 The Cirq Developers +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. \ No newline at end of file diff --git a/cirq-superstaq/cirq_superstaq/qcvv/base_experiment.py b/cirq-superstaq/cirq_superstaq/qcvv/base_experiment.py new file mode 100644 index 000000000..f64d707dd --- /dev/null +++ b/cirq-superstaq/cirq_superstaq/qcvv/base_experiment.py @@ -0,0 +1,413 @@ +# Copyright 2021 The Cirq Developers +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Base experiment class and tools used across all experiments. +""" +from __future__ import annotations + +import warnings +from abc import ABC, abstractmethod +from collections.abc import Iterable, Sequence +from copy import deepcopy +from dataclasses import dataclass, field +from typing import Any, NamedTuple + +import cirq +import numpy as np +import pandas as pd +from general_superstaq.superstaq_exceptions import SuperstaqException +from tqdm.notebook import tqdm + +# from cirq_superstaq.job import Job # noqa: TC002 +from cirq_superstaq.service import Service + + +@dataclass +class Sample: + """A sample circuit to use along with any data about the circuit + that is needed for analysis + """ + + circuit: cirq.Circuit + """The sample circuit.""" + data: dict[str, Any] + """The corresponding data about the circuit""" + probabilities: dict[str, float] = field(init=False) + """The probabilities of the computational basis states""" + + +class BenchmarkingExperiment(ABC): + """Base class for gate benchmarking experiments. + + The interface for implementing these experiments is as follows: + + #. First instantiate the desired experiment object + + .. code:: + + experiment = ExampleExperiment(<>) + + #. Run the experiment on the desired target. This can either be a custom simulator + or a real device name. For example + + .. code:: + + noise_model = cirq.depolarize(p=0.01, n_qubits=1) + target = cirq.DensityMatrixSimulator(noise=noise_model) + + experiment.run(target=target, <>) + + #. Then we analyse the results. If the target was a local simulator this will be available as + soon as the :code:`run()` method has finished executing. On the other hand if a real device + was accessed via Superstaq then this method will not execute until the job has finished + on the Superstaq server. + + .. code:: + + results = experiment.analyse_results(<>) + + #. The final results of the experiment will be stored in the :code:`results` attribute as a + :class:`~typing.NamedTuple` of values, while all the data from the experiment will be + stored in the :code:`raw_data` attribute as a :class:`~pandas.DataFrame`. Some experiments + may include additional data attributes for data generated during the analysis. + + .. code:: + + results = experiment.results + data = experiment.raw_data + + .. warning:: + Note that each time the :code:`run()` method is called the + previous jobs, results and data are overwritten. + + When implementing a new experiment, 4 methods need to be implemented: + + #. :meth:`build_circuits`: Given a number of circuits and an iterable of the different numbers + of layers to use, return a list of :class:`Sample` objects that need to be sampled during + the experiment. + + #. :meth:`process_probabilities`: Take the probability distribution over the + computational basis resulting from running each circuit and combine the relevant details + into the :attr:`_raw_data` dataframe. + + #. :meth:`analyse_results`: Analyse the data in the :attr:`_raw_data` dataframe and return a + :class:`~typing.NamedTuple` like object containing the results of the experiment. + + #. :meth:`plot_results`: Produce any relevant plots that are useful for understanding the + results of the experiment. + + """ + + def __init__( + self, + num_qubits: int, + ) -> None: + """Args: + num_qubits: The number of qubits used during the experiment. Most subclasses + will determine this from their other inputs. + """ + self.qubits = cirq.LineQubit.range(num_qubits) + """The qubits used in the experiment.""" + + self._raw_data: pd.DataFrame | None = None + "The data generated during the experiment" + + self._results: NamedTuple | None = None + """The attribute to store the results in.""" + + self._samples: Sequence[Sample] | None = None + """The attribute to store the experimental samples in.""" + + @property + def results(self) -> NamedTuple: + """The results from the most recently run experiment. + + Raises: + RuntimeError: If no results are available. + """ + if self._results is None: + raise RuntimeError("No results to retrieve. The experiment has not been run.") + + return self._results + + @property + def samples(self) -> Sequence[Sample]: + """The samples generated during the experiment. + + Raises: + RuntimeError: If no samples are available. + """ + if self._samples is None: + raise RuntimeError("No samples to retrieve. The experiment has not been run.") + + return self._samples + + @property + def raw_data(self) -> pd.DataFrame: + """The data from the most recently run experiment. + + Raises: + RuntimeError: If no results are available. + """ + if self._raw_data is None: + raise RuntimeError("No data to retrieve. The experiment has not been run.") + + return self._raw_data + + @property + def num_qubits(self) -> int: + """Returns: + The number of qubits used in the experiment + """ + return len(self.qubits) + + def run( + self, + num_circuits: int, + layers: Iterable[int], + target: cirq.SimulatorBase | str | None = None, # type: ignore [type-arg] + shots: int = 10_000, + dry_run: bool = False, + **service_kwargs: Any, + ) -> None: + """Run the benchmarking experiment and analyse the results. + + Args: + num_circuits: Number of circuits to run. + layers: An iterable of the different layer depths to use during the experiment. + target: Either a local :class:`~cirq.SimulatorBase` to use or the name of a Superstaq + target. If None then a local simulator is used. Defaults to None. + shots: The number of shots to sample. Defaults to 10,000. + dry_run: If the circuits are submitted to the Superstaq server then + using :code:`dry-run=True` will run the circuits in :code:`dry-run` mode. + service_kwargs: Key word arguments to be passed to + the :class:`~cirq_superstaq.service.Service` instance. + """ + if self._results is not None: + warnings.warn("Existing results will be overwritten.") + + if any(depth <= 0 for depth in layers): + raise ValueError("The `layers` iterator can only include positive values.") + + self._samples = self.build_circuits(num_circuits, layers) + self._clean_circuits() + + if target is None: + target = cirq.Simulator() + + if isinstance(target, str): + self.run_ss_jobs(target, shots, dry_run, **service_kwargs) + else: + self.sample_circuits_with_simulator(target, shots) + + self.process_probabilities() + + def _clean_circuits(self) -> None: + """Removes any terminal measurements that have been added to the circuit and replaces + them with a single measurement of the whole system in the computational basis + """ + for sample in self.samples: + if sample.circuit.has_measurements(): + sample.circuit = cirq.drop_terminal_measurements(sample.circuit) + # Add measurement of qubit state in computational basis. + sample.circuit += cirq.measure(sample.circuit.all_qubits()) + + def run_ss_jobs( + self, + target: str, + shots: int = 10_000, + dry_run: bool = False, + all_samples: bool = True, + **service_kwargs: Any, + ) -> None: + """Submit the circuit samples to the desired target device and store the resulting + probabilities. + + The set of circuits is partitioned as necessary to not exceed the maximum circuits that can + be submitted to the given target device. The function then waits for the jobs to complete + before saving the resulting probability distributions. + + Args: + target: The name of the target device. + shots: The number of shots to use. Defaults to 10,000 + dry_run: Whether to perform a dry run on the Superstaq server instead of submitting + to the real device. + all_samples: If False then only sample circuits without saved results are submitted. + Defaults to True. + service_kwargs: Key word arguments to be passed to + the :class:`~cirq_superstaq.service.Service` instance. + """ + # Initialise the service + service = Service(**service_kwargs) + + # Configure dry-runs + if dry_run: + method = "dry-run" + else: + method = None + + if all_samples: + indexes = list(range(len(self.samples))) + else: + indexes = [ + idx + for idx in range(len(self.samples)) + if not hasattr(self.samples[idx], "probabilities") + ] + + # Get maximum number of targets + max_circuits = service.target_info(target=target).get("max_experiments", len(self.samples)) + partitioned_samples = [ + indexes[i : i + max_circuits] for i in range(0, len(indexes), max_circuits) + ] + + for partition in tqdm(partitioned_samples, desc="Submitting jobs to server."): + job = service.create_job( + [self.samples[idx].circuit for idx in partition], + target=target, + method=method, + repetitions=shots, + ) + try: + counts = job.counts() + if not isinstance(counts, list): + raise TypeError("Expected the counts returned from the `job` to be a list.") + for k, idx in enumerate(partition): + self.samples[idx].probabilities = self._process_device_counts(counts[k]) + + except SuperstaqException as error: + warnings.warn( + "An exception occurred while running the experiment on " + "the Superstaq server. As a result not all circuits have been sampled." + "Suggest re-running `run_ss_jobs()` with `all_samples=False` to sample " + f"the missing circuits. Exception message: {error.message}" + ) + + def sample_circuits_with_simulator( + self, target: cirq.SimulatorBase, shots: int = 10_000 # type: ignore [type-arg] + ) -> None: + """Use the local simulator to sample the circuits and store the resulting probabilities. + + Args: + target: The :class:`~cirq.SimulatorBase()` object to use for sampling the circuits with. + shots: The number of shots to use. Defaults to 10,000 + """ + + for sample in tqdm(self.samples, desc="Simulating circuits"): + # Use transpose (.T) to reshape samples output from (n x 1) into (1 x n) + samples = target.sample(sample.circuit, repetitions=shots).values.T[0] + output_probabilities = np.bincount(samples, minlength=2**self.num_qubits) / len(samples) + + sample.probabilities = self._state_probs_to_dict(output_probabilities) + + @abstractmethod + def build_circuits( + self, + num_circuits: int, + layers: Iterable[int], + ) -> Sequence[Sample]: + """Build a list of circuits required for the experiment. These circuits are stored in + :class:`Sample` objects along with any additional data that is needed during the analysis. + + Args: + num_circuits: Number of circuits to generate. + layers: An iterable of the different layer depths to use during the experiment. + + Returns: + The list of circuit objects + """ + + @abstractmethod + def process_probabilities(self) -> None: + """Processes the probabilities generated by sampling the circuits into the data structures + needed for analyzing the results. Uses the data saved in the :attr:`_samples` attribute and + saves the raw data in the :attr:`_raw_data` attribute ready to + be analyzed when the :meth:`analyse_results` method is called. + + .. note:: + + Any subclasses should call this base method. + + Raises: + RuntimeError: If not all circuits have been sampled. + """ + missing_data = [sample for sample in self.samples if not hasattr(sample, "probabilities")] + if missing_data: + raise RuntimeError("Not all circuits have been successfully sampled.") + + @abstractmethod + def plot_results(self) -> None: + """Plot the results of the experiment""" + + @abstractmethod + def analyse_results(self, plot_results: bool = True) -> NamedTuple: + """Perform the experiment analysis and store the results in the `results` attribute""" + + def _state_probs_to_dict( + self, probs: np.typing.NDArray[np.float64], prefix: str = "", suffix: str = "" + ) -> dict[str, float]: + """Converts a numpy array of state probabilities to a dictionary indexed + by the bitstring. Optional prefix and suffix can be added. + + Args: + probs: Numpy array of coefficients. + prefix: Optional prefix to the bitstring key. Defaults to "". + suffix: Optional suffix to the bitstring key. Defaults to "". + + Returns: + Dictionary of state probabilities indexed by bitstring. + """ + return { + prefix + format(idx, f"0{self.num_qubits}b") + suffix: coefficient + for idx, coefficient in enumerate(probs) + } + + @staticmethod + def _interleave_gate( + circuit: cirq.Circuit, gate: cirq.Gate, include_final: bool = False + ) -> cirq.Circuit: + """Interleave a given gate into a circuit. + + Args: + circuit: The original circuit. + gate: The gate to interleave. + include_final: If True then the interleaving gate is also appended to + the end of the circuit. + + Returns: + A copy of the original circuit with the provided gate interleaved. + """ + qubits = circuit.all_qubits() + interleaved_circuit = deepcopy(circuit) + for k in range(len(circuit) - int(not include_final), 0, -1): + interleaved_circuit.insert(k, gate(*qubits)) + return interleaved_circuit + + def _process_device_counts(self, counts: dict[str, int]) -> dict[str, float]: + """Process the counts returned by the server into a dictionary of probabilities. + + Args: + counts: A dictionary of the observed counts for each state in the computational basis. + + Returns: + A dictionary of the probability of each state in the computational basis. + """ + total = sum(counts.values()) + + probabilities = { + format(idx, f"0{self.num_qubits}b"): 0.0 for idx in range(2**self.num_qubits) + } + + for key, count in counts.items(): + probabilities[key] = count / total + + return probabilities diff --git a/cirq-superstaq/cirq_superstaq/qcvv/base_experiment_test.py b/cirq-superstaq/cirq_superstaq/qcvv/base_experiment_test.py new file mode 100644 index 000000000..8d8a223ce --- /dev/null +++ b/cirq-superstaq/cirq_superstaq/qcvv/base_experiment_test.py @@ -0,0 +1,383 @@ +# Copyright 2021 The Cirq Developers +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# pylint: disable=missing-function-docstring +# mypy: disable-error-code=method-assign + +from __future__ import annotations + +import os +from typing import NamedTuple +from unittest.mock import MagicMock, call, patch + +import cirq +import numpy as np +import pandas as pd +import pytest +from general_superstaq.superstaq_exceptions import SuperstaqException + +from cirq_superstaq.qcvv.base_experiment import BenchmarkingExperiment, Sample + + +@pytest.fixture(scope="session", autouse=True) +def patch_tqdm() -> None: + os.environ["TQDM_DISABLE"] = "1" + + +@pytest.fixture +@patch.multiple(BenchmarkingExperiment, __abstractmethods__=set()) +def abc_experiment() -> BenchmarkingExperiment: + return BenchmarkingExperiment(num_qubits=2) # type: ignore[abstract] + + +@pytest.fixture +def sample_circuits() -> list[Sample]: + qubits = cirq.LineQubit.range(2) + return [ + Sample( + circuit=cirq.Circuit(cirq.CZ(*qubits), cirq.MeasurementGate(num_qubits=2)(*qubits)), + data={"circuit": 1}, + ), + Sample(circuit=cirq.Circuit(cirq.CX(*qubits)), data={"circuit": 2}), + ] + + +class ExampleResults(NamedTuple): + """NamedTuple instance to use for testing""" + + example: float + + +def test_benchmarking_experiment_init(abc_experiment: BenchmarkingExperiment) -> None: + assert abc_experiment.num_qubits == 2 + assert abc_experiment._raw_data is None + assert abc_experiment._results is None + assert abc_experiment._samples is None + + abc_experiment._raw_data = pd.DataFrame([{"Example": 0.1}]) + abc_experiment._results = ExampleResults(example=5.0) + + pd.testing.assert_frame_equal(abc_experiment.raw_data, abc_experiment._raw_data) + assert abc_experiment.results == abc_experiment._results + + +def test_empty_results_error(abc_experiment: BenchmarkingExperiment) -> None: + with pytest.raises( + RuntimeError, match="No results to retrieve. The experiment has not been run." + ): + _ = abc_experiment.results + + +def test_empty_data_error(abc_experiment: BenchmarkingExperiment) -> None: + with pytest.raises(RuntimeError, match="No data to retrieve. The experiment has not been run."): + _ = abc_experiment.raw_data + + +def test_empty_samples_error(abc_experiment: BenchmarkingExperiment) -> None: + with pytest.raises( + RuntimeError, match="No samples to retrieve. The experiment has not been run." + ): + _ = abc_experiment.samples + + +def test_run_results_overwrite_warning(abc_experiment: BenchmarkingExperiment) -> None: + abc_experiment._results = pd.DataFrame([{"example": 1234}]) + abc_experiment.build_circuits = MagicMock() + abc_experiment.run_ss_jobs = MagicMock() + abc_experiment.sample_circuits_with_simulator = MagicMock() + abc_experiment.process_probabilities = MagicMock() + + print(abc_experiment._results) + with pytest.warns(UserWarning, match="Existing results will be overwritten."): + abc_experiment.run(100, [1, 50, 100]) + + +def test_run_with_bad_layers(abc_experiment: BenchmarkingExperiment) -> None: + with pytest.raises(ValueError, match="The `layers` iterator can only include positive values."): + abc_experiment.run(20, [0]) + + +def test_run_local(abc_experiment: BenchmarkingExperiment) -> None: + abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) + abc_experiment.run_ss_jobs = (mock_run_ss_jobs := MagicMock()) + abc_experiment.sample_circuits_with_simulator = ( + mock_sample_circuits_with_simulator := MagicMock() + ) + abc_experiment.process_probabilities = (mock_process_probabilities := MagicMock()) + + abc_experiment.run(50, [1, 50, 100], shots=50) + + mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) + + mock_sample_circuits_with_simulator.assert_called_once() + call_args = mock_sample_circuits_with_simulator.call_args_list[0][0] + assert call_args[1] == 50 + assert isinstance(call_args[0], cirq.Simulator) # Test simulated on a default target + + mock_process_probabilities.assert_called_once_with() + mock_run_ss_jobs.assert_not_called() + + +def test_run_local_defined_sim(abc_experiment: BenchmarkingExperiment) -> None: + abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) + abc_experiment.run_ss_jobs = (mock_run_ss_jobs := MagicMock()) + abc_experiment.sample_circuits_with_simulator = ( + mock_sample_circuits_with_simulator := MagicMock() + ) + abc_experiment.process_probabilities = (mock_process_probabilities := MagicMock()) + + abc_experiment.run( + 50, [1, 50, 100], shots=50, target=(target_sim := cirq.DensityMatrixSimulator()) + ) + + mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) + + mock_sample_circuits_with_simulator.assert_called_once() + call_args = mock_sample_circuits_with_simulator.call_args_list[0][0] + assert call_args[1] == 50 + assert call_args[0] == target_sim # Test simulated on the given target + + mock_process_probabilities.assert_called_once_with() + mock_run_ss_jobs.assert_not_called() + + +def test_run_on_ss_server(abc_experiment: BenchmarkingExperiment) -> None: + abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) + abc_experiment.run_ss_jobs = (mock_run_ss_jobs := MagicMock()) + abc_experiment.sample_circuits_with_simulator = ( + mock_sample_circuits_with_simulator := MagicMock() + ) + abc_experiment.process_probabilities = (mock_process_probabilities := MagicMock()) + + abc_experiment.run(50, [1, 50, 100], shots=50, target="example_ss_target") + + mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) + + mock_sample_circuits_with_simulator.assert_not_called() + + mock_process_probabilities.assert_called_once_with() + mock_run_ss_jobs.assert_called_once_with("example_ss_target", 50, False) + + +def test_run_with_simulator( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + test_target = MagicMock(spec=cirq.Simulator) + test_target.sample = MagicMock( + return_value=MagicMock(values=np.ones(shape=(100, 1), dtype=np.int64)) + ) + + abc_experiment.sample_circuits_with_simulator(test_target, shots=100) + + # Test simulator calls + test_target.sample.assert_has_calls( + [ + call(sample_circuits[0].circuit, repetitions=100), + call(sample_circuits[1].circuit, repetitions=100), + ] + ) + + # Test probabilities + assert sample_circuits[0].probabilities == {"00": 0.0, "01": 1.0, "10": 0.0, "11": 0.0} + assert sample_circuits[1].probabilities == {"00": 0.0, "01": 1.0, "10": 0.0, "11": 0.0} + + +def test_run_ss_jobs(abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample]) -> None: + + abc_experiment._samples = sample_circuits + with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + mock_service().create_job.return_value = MagicMock( + counts=MagicMock( + return_value=[ + {"00": 5, "01": 5, "10": 5, "11": 10}, + {"00": 5, "01": 5, "10": 5, "11": 10}, + ] + ) + ) + mock_service().target_info.return_value = {} + abc_experiment.run_ss_jobs("example_target", shots=100) + + for sample in sample_circuits: + assert sample.probabilities == {"00": 0.2, "01": 0.2, "10": 0.2, "11": 0.4} + + mock_service().create_job.assert_called_once_with( + [sample.circuit for sample in sample_circuits], + target="example_target", + method=None, + repetitions=100, + ) + + +def test_run_ss_jobs_not_all_samples( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + + abc_experiment._samples = sample_circuits + abc_experiment._samples[0].probabilities = {"example": 0.7} + with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + mock_service().create_job.return_value = MagicMock( + counts=MagicMock( + return_value=[ + {"00": 5, "01": 5, "10": 5, "11": 10}, + {"00": 5, "01": 5, "10": 5, "11": 10}, + ] + ) + ) + mock_service().target_info.return_value = {} + abc_experiment.run_ss_jobs("example_target", shots=100, all_samples=False) + + assert sample_circuits[1].probabilities == {"00": 0.2, "01": 0.2, "10": 0.2, "11": 0.4} + + mock_service().create_job.assert_called_once_with( + [sample_circuits[1].circuit], + target="example_target", + method=None, + repetitions=100, + ) + + +def test_run_ss_jobs_dry_run_partitioning( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + + abc_experiment._samples = sample_circuits + with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + mock_service().create_job.return_value = MagicMock( + counts=MagicMock( + return_value=[ + {"00": 5, "01": 5, "10": 5, "11": 10}, + {"00": 5, "01": 5, "10": 5, "11": 10}, + ] + ) + ) + mock_service().target_info.return_value = {"max_experiments": 1} + abc_experiment.run_ss_jobs("example_target", shots=100, dry_run=True) + + for sample in sample_circuits: + assert sample.probabilities == {"00": 0.2, "01": 0.2, "10": 0.2, "11": 0.4} + + mock_service().create_job.assert_has_calls( + [ + call( + [sample_circuits[0].circuit], + target="example_target", + method="dry-run", + repetitions=100, + ), + call().counts(), + call( + [sample_circuits[1].circuit], + target="example_target", + method="dry-run", + repetitions=100, + ), + call().counts(), + ] + ) + + +def test_run_ss_jobs_with_exception( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + mock_service().create_job.return_value = MagicMock( + counts=MagicMock(side_effect=SuperstaqException("example_exception")) + ) + with pytest.warns(UserWarning): + abc_experiment.run_ss_jobs("example_target", shots=100, dry_run=True) + + +def test_state_probs_to_dict(abc_experiment: BenchmarkingExperiment) -> None: + probabilities = np.array([0.1, 0.2, 0.3, 0.4]) + out_dict = abc_experiment._state_probs_to_dict(probabilities) + assert out_dict == { + "00": 0.1, + "01": 0.2, + "10": 0.3, + "11": 0.4, + } + + +def test_interleave_circuit() -> None: + qubit = cirq.LineQubit(0) + circuit = cirq.Circuit(*[cirq.X(qubit) for _ in range(4)]) + + # With last gate + interleaved_circuit = BenchmarkingExperiment._interleave_gate( + circuit, cirq.Z, include_final=True + ) + cirq.testing.assert_same_circuits( + interleaved_circuit, + cirq.Circuit( + cirq.X(qubit), + cirq.Z(qubit), + cirq.X(qubit), + cirq.Z(qubit), + cirq.X(qubit), + cirq.Z(qubit), + cirq.X(qubit), + cirq.Z(qubit), + ), + ) + + # Without last gate + interleaved_circuit = BenchmarkingExperiment._interleave_gate( + circuit, cirq.Z, include_final=False + ) + cirq.testing.assert_same_circuits( + interleaved_circuit, + cirq.Circuit( + cirq.X(qubit), + cirq.Z(qubit), + cirq.X(qubit), + cirq.Z(qubit), + cirq.X(qubit), + cirq.Z(qubit), + cirq.X(qubit), + ), + ) + + +def test_clean_circuit( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + abc_experiment._clean_circuits() + + for sample in sample_circuits: + assert sample.circuit[-1] == cirq.Moment(cirq.measure(*sample.circuit.all_qubits())) + + +def test_process_probabilities( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + with pytest.raises(RuntimeError, match="Not all circuits have been successfully sampled."): + abc_experiment.process_probabilities() + + +def test_run_ss_jobs_counts_not_list( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + mock_service().create_job.return_value = MagicMock( + counts=MagicMock(return_value={"00": 5, "01": 5, "10": 5, "11": 10}) + ) + mock_service().target_info.return_value = {} + with pytest.raises( + TypeError, match="Expected the counts returned from the `job` to be a list." + ): + abc_experiment.run_ss_jobs("example_target", shots=100) diff --git a/docs/source/apps/qcvv/qcvv.rst b/docs/source/apps/qcvv/qcvv.rst new file mode 100644 index 000000000..963ceed6d --- /dev/null +++ b/docs/source/apps/qcvv/qcvv.rst @@ -0,0 +1,17 @@ +QCVV: Quantum Characterisation, Validation and Verification +=========================================================== + +The Superstaq QCVV library provides a customizable toolkit for testing and characterizing +quantum devices. The toolkit can either be used with simulators or on live devices. + +For a demonstration of how to implement a new experiment take a look at the following notebook + +.. toctree:: + :maxdepth: 1 + + qcvv_css + + +.. note:: + + At present the QCVV library is only available in :code:`cirq-superstaq`. \ No newline at end of file diff --git a/docs/source/apps/qcvv/qcvv_css.ipynb b/docs/source/apps/qcvv/qcvv_css.ipynb new file mode 100644 index 000000000..8c5269caa --- /dev/null +++ b/docs/source/apps/qcvv/qcvv_css.ipynb @@ -0,0 +1,235 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quantum Characterisation, Verification and Validation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To demonstrate how to implement new benchmarking experiments within the Superstaq QCVV framework,\n", + "consider implementing a naive benchmarking routine where we try to estimate the fidelity of a single\n", + "qubit Z gate by repeatedly applying the gate to a qubit in the ground state (such that the Z-gate\n", + "should have no effect) and observing if any observations of the excited state occur. If the excited \n", + "state is observed this indicates an error has occurred. Assuming that each time the Z-gate is\n", + "applied the probability of a bit flip error is $e$ then after $d$ gates the probability of \n", + "observing the ground state is $$p(0) = \\frac{1}{2}(1-e)^d + \\frac{1}{2}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can create an experiment to measure this as follows" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "from cirq_superstaq.qcvv.base_experiment import BenchmarkingExperiment\n", + "from collections.abc import Sequence\n", + "from typing import Iterable, NamedTuple\n", + "from tqdm.contrib.itertools import product\n", + "import pandas as pd\n", + "\n", + "import cirq\n", + "\n", + "from scipy.stats import linregress\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from cirq_superstaq.qcvv.base_experiment import Sample\n", + "\n", + "\n", + "class NaiveExperimentResult(NamedTuple):\n", + " gate_fidelity: float\n", + " gate_error: float\n", + "\n", + "\n", + "class NaiveExperiment(BenchmarkingExperiment):\n", + " def __init__(self):\n", + " super().__init__(num_qubits=1)\n", + "\n", + " def build_circuits(self, num_circuits: int, layers: Iterable[int]) -> Sequence[Sample]:\n", + " \"\"\"Build the circuits by composing multiple Z gates together into circuits. The\n", + " number of gates to compose is given by the `layers` parameter.\n", + " \"\"\"\n", + " samples = []\n", + " for _, depth in product(range(num_circuits), layers, desc=\"Building circuits.\"):\n", + " circuit = cirq.Circuit([cirq.Z(*self.qubits) for _ in range(depth)])\n", + " samples.append(Sample(circuit=circuit, data={\"depth\": depth}))\n", + " return samples\n", + "\n", + " def process_probabilities(self) -> None:\n", + " \"\"\"Copy the data and observed probabilities into a pandas DataFrame.\"\"\"\n", + " super().process_probabilities()\n", + " records = []\n", + " for sample in self.samples:\n", + " records.append({**sample.data, **sample.probabilities})\n", + " self._raw_data = pd.DataFrame(records)\n", + "\n", + " def analyse_results(self, plot_results: bool = True) -> NamedTuple:\n", + " \"\"\"To analyse the results to fit a simple exponential decay. This can be done easily\n", + " by fitting a linear model to the logarithm of the equation above.\n", + " \"\"\"\n", + "\n", + " model = linregress(x=self.raw_data[\"depth\"], y=np.log(2 * self.raw_data[\"0\"] - 1))\n", + "\n", + " fidelity = np.exp(model.slope)\n", + "\n", + " self._results = NaiveExperimentResult(gate_fidelity=fidelity, gate_error=1 - fidelity)\n", + "\n", + " if plot_results:\n", + " self.plot_results()\n", + "\n", + " return self.results\n", + "\n", + " def plot_results(self) -> None:\n", + " \"\"\"Plot the data with the fit superimposed on top.\"\"\"\n", + "\n", + " fig, axs = plt.subplots(\n", + " 1,\n", + " )\n", + "\n", + " sns.scatterplot(self.raw_data, x=\"depth\", y=\"0\", ax=axs)\n", + "\n", + " x = np.linspace(0, max(self.raw_data.depth))\n", + " y = 0.5 * self.results.gate_fidelity**x + 0.5\n", + " axs.plot(x, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To test this basic experiment, we use a depolarising noise model and a density matrix simulator.\n", + "Note that if we use a single qubit depolarising channel with rate $p$ this will result in a bit-flip\n", + "error with probability of $4p/3$." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b9bb64d74a964b398bae86e0a7725c55", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/200 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "noise = cirq.DepolarizingChannel(p=0.01)\n", + "simulator = cirq.DensityMatrixSimulator(noise=noise)\n", + "experiment = NaiveExperiment()\n", + "experiment.run(50, [1, 10, 50, 100], target=simulator)\n", + "experiment.analyse_results(plot_results=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Checking this result we have" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.009973840110814286\n" + ] + } + ], + "source": [ + "channel_rate = 3 / 4 * experiment.results.gate_error\n", + "print(channel_rate)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Which agrees very closely with our channel rate of $0.01$" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "client_superstaq", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/source/cirq_superstaq.qcvv.rst b/docs/source/cirq_superstaq.qcvv.rst new file mode 100644 index 000000000..ac9398a95 --- /dev/null +++ b/docs/source/cirq_superstaq.qcvv.rst @@ -0,0 +1,21 @@ +cirq\_superstaq.qcvv package +============================ + +Submodules +---------- + +cirq\_superstaq.qcvv.base\_experiment module +-------------------------------------------- + +.. automodule:: cirq_superstaq.qcvv.base_experiment + :members: + :undoc-members: + :show-inheritance: + +Module contents +--------------- + +.. automodule:: cirq_superstaq.qcvv + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/index.rst b/docs/source/index.rst index 63efd28c3..3ead159bc 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -6,7 +6,7 @@ Superstaq Documentation ======================= Welcome! Here you can find more about Infleqtion's state-of-the-art quantum software platform that uses proprietary cross-layer optimization techniques to deliver unmatched performance. - + .. raw:: html
@@ -62,6 +62,7 @@ Learn more about Superstaq `here `_. To co apps/max_sharpe_ratio_optimization apps/dfe/dfe apps/aces/aces + apps/qcvv/qcvv .. toctree:: :maxdepth: 1 From 0aa0d419b814f400b0e89f33b1a4d86f7988d767 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Tue, 16 Jul 2024 09:41:44 +0100 Subject: [PATCH 02/32] nit: add blank line --- cirq-superstaq/cirq_superstaq/qcvv/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cirq-superstaq/cirq_superstaq/qcvv/__init__.py b/cirq-superstaq/cirq_superstaq/qcvv/__init__.py index b530814bd..ab56a6f87 100644 --- a/cirq-superstaq/cirq_superstaq/qcvv/__init__.py +++ b/cirq-superstaq/cirq_superstaq/qcvv/__init__.py @@ -10,4 +10,4 @@ # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and -# limitations under the License. \ No newline at end of file +# limitations under the License. From 41bcc9be56f32170907073c39d94d126bc606987 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 19 Jul 2024 08:49:37 +0100 Subject: [PATCH 03/32] Move qcvv to Supermarq --- cirq-superstaq/cirq_superstaq/__init__.py | 3 +-- .../cirq_superstaq/qcvv/__init__.py | 13 ------------ docs/source/cirq_superstaq.qcvv.rst | 21 ------------------- .../examples}/qcvv/qcvv.rst | 7 +------ .../examples}/qcvv/qcvv_css.ipynb | 0 supermarq-benchmarks/supermarq/__init__.py | 3 ++- .../supermarq/qcvv/__init__.py | 1 + .../supermarq}/qcvv/base_experiment.py | 0 .../supermarq}/qcvv/base_experiment_test.py | 2 +- 9 files changed, 6 insertions(+), 44 deletions(-) delete mode 100644 cirq-superstaq/cirq_superstaq/qcvv/__init__.py delete mode 100644 docs/source/cirq_superstaq.qcvv.rst rename {docs/source/apps => supermarq-benchmarks/examples}/qcvv/qcvv.rst (70%) rename {docs/source/apps => supermarq-benchmarks/examples}/qcvv/qcvv_css.ipynb (100%) create mode 100644 supermarq-benchmarks/supermarq/qcvv/__init__.py rename {cirq-superstaq/cirq_superstaq => supermarq-benchmarks/supermarq}/qcvv/base_experiment.py (100%) rename {cirq-superstaq/cirq_superstaq => supermarq-benchmarks/supermarq}/qcvv/base_experiment_test.py (99%) diff --git a/cirq-superstaq/cirq_superstaq/__init__.py b/cirq-superstaq/cirq_superstaq/__init__.py index b8ae8659a..5b2aad57f 100644 --- a/cirq-superstaq/cirq_superstaq/__init__.py +++ b/cirq-superstaq/cirq_superstaq/__init__.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from cirq_superstaq import compiler_output, qcvv, validation +from cirq_superstaq import compiler_output, validation from cirq_superstaq._version import __version__ from cirq_superstaq.compiler_output import active_qubit_indices, measured_qubit_indices from cirq_superstaq.job import Job @@ -104,7 +104,6 @@ "compiler_output", "deserialize_circuits", "parallel_gates_operation", - "qcvv", "qubit_subspace_op", "qudit_swap_op", "serialize_circuits", diff --git a/cirq-superstaq/cirq_superstaq/qcvv/__init__.py b/cirq-superstaq/cirq_superstaq/qcvv/__init__.py deleted file mode 100644 index ab56a6f87..000000000 --- a/cirq-superstaq/cirq_superstaq/qcvv/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# Copyright 2021 The Cirq Developers -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. diff --git a/docs/source/cirq_superstaq.qcvv.rst b/docs/source/cirq_superstaq.qcvv.rst deleted file mode 100644 index ac9398a95..000000000 --- a/docs/source/cirq_superstaq.qcvv.rst +++ /dev/null @@ -1,21 +0,0 @@ -cirq\_superstaq.qcvv package -============================ - -Submodules ----------- - -cirq\_superstaq.qcvv.base\_experiment module --------------------------------------------- - -.. automodule:: cirq_superstaq.qcvv.base_experiment - :members: - :undoc-members: - :show-inheritance: - -Module contents ---------------- - -.. automodule:: cirq_superstaq.qcvv - :members: - :undoc-members: - :show-inheritance: diff --git a/docs/source/apps/qcvv/qcvv.rst b/supermarq-benchmarks/examples/qcvv/qcvv.rst similarity index 70% rename from docs/source/apps/qcvv/qcvv.rst rename to supermarq-benchmarks/examples/qcvv/qcvv.rst index 963ceed6d..9648b27c1 100644 --- a/docs/source/apps/qcvv/qcvv.rst +++ b/supermarq-benchmarks/examples/qcvv/qcvv.rst @@ -1,7 +1,7 @@ QCVV: Quantum Characterisation, Validation and Verification =========================================================== -The Superstaq QCVV library provides a customizable toolkit for testing and characterizing +The Supermarq QCVV library provides a customizable toolkit for testing and characterizing quantum devices. The toolkit can either be used with simulators or on live devices. For a demonstration of how to implement a new experiment take a look at the following notebook @@ -10,8 +10,3 @@ For a demonstration of how to implement a new experiment take a look at the foll :maxdepth: 1 qcvv_css - - -.. note:: - - At present the QCVV library is only available in :code:`cirq-superstaq`. \ No newline at end of file diff --git a/docs/source/apps/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb similarity index 100% rename from docs/source/apps/qcvv/qcvv_css.ipynb rename to supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb diff --git a/supermarq-benchmarks/supermarq/__init__.py b/supermarq-benchmarks/supermarq/__init__.py index 3500c83d0..86d798bea 100644 --- a/supermarq-benchmarks/supermarq/__init__.py +++ b/supermarq-benchmarks/supermarq/__init__.py @@ -1,4 +1,4 @@ -from . import benchmark, converters, features, plotting, simulation, stabilizers +from . import benchmark, converters, features, plotting, qcvv, simulation, stabilizers from ._version import __version__ from .benchmarks import ( bit_code, @@ -27,4 +27,5 @@ "simulation", "stabilizers", "vqe_proxy", + "qcvv", ] diff --git a/supermarq-benchmarks/supermarq/qcvv/__init__.py b/supermarq-benchmarks/supermarq/qcvv/__init__.py new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/supermarq-benchmarks/supermarq/qcvv/__init__.py @@ -0,0 +1 @@ + diff --git a/cirq-superstaq/cirq_superstaq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py similarity index 100% rename from cirq-superstaq/cirq_superstaq/qcvv/base_experiment.py rename to supermarq-benchmarks/supermarq/qcvv/base_experiment.py diff --git a/cirq-superstaq/cirq_superstaq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py similarity index 99% rename from cirq-superstaq/cirq_superstaq/qcvv/base_experiment_test.py rename to supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index 8d8a223ce..c8de491b8 100644 --- a/cirq-superstaq/cirq_superstaq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -26,7 +26,7 @@ import pytest from general_superstaq.superstaq_exceptions import SuperstaqException -from cirq_superstaq.qcvv.base_experiment import BenchmarkingExperiment, Sample +from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample @pytest.fixture(scope="session", autouse=True) From 17b585bdfdb683367a28e4c02fde77bc813f53bb Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 19 Jul 2024 08:55:07 +0100 Subject: [PATCH 04/32] Fix imports and tests --- supermarq-benchmarks/supermarq/qcvv/__init__.py | 2 +- supermarq-benchmarks/supermarq/qcvv/base_experiment.py | 4 ++-- .../supermarq/qcvv/base_experiment_test.py | 10 +++++----- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/__init__.py b/supermarq-benchmarks/supermarq/qcvv/__init__.py index 8b1378917..4c0a5dc54 100644 --- a/supermarq-benchmarks/supermarq/qcvv/__init__.py +++ b/supermarq-benchmarks/supermarq/qcvv/__init__.py @@ -1 +1 @@ - +"""A toolkit of QCVV routines.""" diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index f64d707dd..97ff3da96 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -24,11 +24,11 @@ import cirq import numpy as np import pandas as pd -from general_superstaq.superstaq_exceptions import SuperstaqException -from tqdm.notebook import tqdm # from cirq_superstaq.job import Job # noqa: TC002 from cirq_superstaq.service import Service +from general_superstaq.superstaq_exceptions import SuperstaqException +from tqdm.notebook import tqdm @dataclass diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index c8de491b8..e1a498af3 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -196,7 +196,7 @@ def test_run_with_simulator( def test_run_ss_jobs(abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample]) -> None: abc_experiment._samples = sample_circuits - with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + with patch("supermarq.qcvv.base_experiment.Service") as mock_service: mock_service().create_job.return_value = MagicMock( counts=MagicMock( return_value=[ @@ -225,7 +225,7 @@ def test_run_ss_jobs_not_all_samples( abc_experiment._samples = sample_circuits abc_experiment._samples[0].probabilities = {"example": 0.7} - with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + with patch("supermarq.qcvv.base_experiment.Service") as mock_service: mock_service().create_job.return_value = MagicMock( counts=MagicMock( return_value=[ @@ -252,7 +252,7 @@ def test_run_ss_jobs_dry_run_partitioning( ) -> None: abc_experiment._samples = sample_circuits - with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + with patch("supermarq.qcvv.base_experiment.Service") as mock_service: mock_service().create_job.return_value = MagicMock( counts=MagicMock( return_value=[ @@ -291,7 +291,7 @@ def test_run_ss_jobs_with_exception( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + with patch("supermarq.qcvv.base_experiment.Service") as mock_service: mock_service().create_job.return_value = MagicMock( counts=MagicMock(side_effect=SuperstaqException("example_exception")) ) @@ -372,7 +372,7 @@ def test_run_ss_jobs_counts_not_list( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - with patch("cirq_superstaq.qcvv.base_experiment.Service") as mock_service: + with patch("supermarq.qcvv.base_experiment.Service") as mock_service: mock_service().create_job.return_value = MagicMock( counts=MagicMock(return_value={"00": 5, "01": 5, "10": 5, "11": 10}) ) From 6dbdfa2194ed717976da7f10d8a7acc05037485b Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 19 Jul 2024 12:03:00 +0100 Subject: [PATCH 05/32] Revised results processing --- .../supermarq/qcvv/base_experiment.py | 197 +++++++++++------- 1 file changed, 122 insertions(+), 75 deletions(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index 97ff3da96..12ef079c8 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -24,10 +24,8 @@ import cirq import numpy as np import pandas as pd - -# from cirq_superstaq.job import Job # noqa: TC002 from cirq_superstaq.service import Service -from general_superstaq.superstaq_exceptions import SuperstaqException +from general_superstaq.superstaq_exceptions import SuperstaqServerException from tqdm.notebook import tqdm @@ -43,6 +41,9 @@ class Sample: """The corresponding data about the circuit""" probabilities: dict[str, float] = field(init=False) """The probabilities of the computational basis states""" + job: str | None = None + """The superstaq job UUID corresponding to the sample. Defaults to None if no job is + associated with the sample.""" class BenchmarkingExperiment(ABC): @@ -68,12 +69,13 @@ class BenchmarkingExperiment(ABC): #. Then we analyse the results. If the target was a local simulator this will be available as soon as the :code:`run()` method has finished executing. On the other hand if a real device - was accessed via Superstaq then this method will not execute until the job has finished - on the Superstaq server. + was accessed via Superstaq then it may take time for the data to be available from the + server. The :code:`collect_data()` will return :code:`True` when all data has been collected + and is ready to be analysed. .. code:: - - results = experiment.analyse_results(<>) + if self.collect_data(): + results = experiment.analyse_results(<>) #. The final results of the experiment will be stored in the :code:`results` attribute as a :class:`~typing.NamedTuple` of values, while all the data from the experiment will be @@ -97,10 +99,10 @@ class BenchmarkingExperiment(ABC): #. :meth:`process_probabilities`: Take the probability distribution over the computational basis resulting from running each circuit and combine the relevant details - into the :attr:`_raw_data` dataframe. + into a :class:`pandas.DataFrame`. - #. :meth:`analyse_results`: Analyse the data in the :attr:`_raw_data` dataframe and return a - :class:`~typing.NamedTuple` like object containing the results of the experiment. + #. :meth:`analyse_results`: Analyse the data in the :attr:`raw_data` dataframe and return a + :class:`~typing.NamedTuple`-like object containing the results of the experiment. #. :meth:`plot_results`: Produce any relevant plots that are useful for understanding the results of the experiment. @@ -110,6 +112,7 @@ class BenchmarkingExperiment(ABC): def __init__( self, num_qubits: int, + **kwargs: Any, ) -> None: """Args: num_qubits: The number of qubits used during the experiment. Most subclasses @@ -127,6 +130,8 @@ def __init__( self._samples: Sequence[Sample] | None = None """The attribute to store the experimental samples in.""" + self._service: Service = Service(**kwargs) + @property def results(self) -> NamedTuple: """The results from the most recently run experiment. @@ -177,7 +182,6 @@ def run( target: cirq.SimulatorBase | str | None = None, # type: ignore [type-arg] shots: int = 10_000, dry_run: bool = False, - **service_kwargs: Any, ) -> None: """Run the benchmarking experiment and analyse the results. @@ -189,10 +193,8 @@ def run( shots: The number of shots to sample. Defaults to 10,000. dry_run: If the circuits are submitted to the Superstaq server then using :code:`dry-run=True` will run the circuits in :code:`dry-run` mode. - service_kwargs: Key word arguments to be passed to - the :class:`~cirq_superstaq.service.Service` instance. """ - if self._results is not None: + if self._samples is not None: warnings.warn("Existing results will be overwritten.") if any(depth <= 0 for depth in layers): @@ -205,12 +207,10 @@ def run( target = cirq.Simulator() if isinstance(target, str): - self.run_ss_jobs(target, shots, dry_run, **service_kwargs) + self.submit_ss_jobs(target, shots, dry_run) else: self.sample_circuits_with_simulator(target, shots) - self.process_probabilities() - def _clean_circuits(self) -> None: """Removes any terminal measurements that have been added to the circuit and replaces them with a single measurement of the whole system in the computational basis @@ -221,13 +221,11 @@ def _clean_circuits(self) -> None: # Add measurement of qubit state in computational basis. sample.circuit += cirq.measure(sample.circuit.all_qubits()) - def run_ss_jobs( + def submit_ss_jobs( self, target: str, shots: int = 10_000, dry_run: bool = False, - all_samples: bool = True, - **service_kwargs: Any, ) -> None: """Submit the circuit samples to the desired target device and store the resulting probabilities. @@ -241,13 +239,7 @@ def run_ss_jobs( shots: The number of shots to use. Defaults to 10,000 dry_run: Whether to perform a dry run on the Superstaq server instead of submitting to the real device. - all_samples: If False then only sample circuits without saved results are submitted. - Defaults to True. - service_kwargs: Key word arguments to be passed to - the :class:`~cirq_superstaq.service.Service` instance. """ - # Initialise the service - service = Service(**service_kwargs) # Configure dry-runs if dry_run: @@ -255,42 +247,60 @@ def run_ss_jobs( else: method = None - if all_samples: - indexes = list(range(len(self.samples))) - else: - indexes = [ - idx - for idx in range(len(self.samples)) - if not hasattr(self.samples[idx], "probabilities") - ] - - # Get maximum number of targets - max_circuits = service.target_info(target=target).get("max_experiments", len(self.samples)) - partitioned_samples = [ - indexes[i : i + max_circuits] for i in range(0, len(indexes), max_circuits) - ] - - for partition in tqdm(partitioned_samples, desc="Submitting jobs to server."): - job = service.create_job( - [self.samples[idx].circuit for idx in partition], - target=target, - method=method, - repetitions=shots, - ) + for sample in tqdm(self.samples): + if sample.job is not None: + continue try: - counts = job.counts() - if not isinstance(counts, list): - raise TypeError("Expected the counts returned from the `job` to be a list.") - for k, idx in enumerate(partition): - self.samples[idx].probabilities = self._process_device_counts(counts[k]) - - except SuperstaqException as error: - warnings.warn( - "An exception occurred while running the experiment on " - "the Superstaq server. As a result not all circuits have been sampled." - "Suggest re-running `run_ss_jobs()` with `all_samples=False` to sample " - f"the missing circuits. Exception message: {error.message}" + job = self._service.create_job( + sample.circuit, target=target, method=method, repetitions=shots ) + sample.job = job.job_id() + except SuperstaqServerException as error: + print( + "The following error ocurred when submitting the jobs to the server and not\n" + "all jobs have been submitted. If this is a timeout or limit based error\n" + "consider running `submit_ss_jobs(args)` again to continue submitting\n" + "the outstanding jobs.\n" + f"{error.message}" + ) + + def sample_statuses(self) -> list[str | None]: + """Returns: + Get the statuses of the jobs associated with each sample. If no job is associated + with a sample then :code:`None` is listed instead. + """ + statuses: list[str | None] = [] + for sample in self.samples: + if sample.job is None: + statuses.append(None) + else: + statuses.append(self._service.get_job(sample.job).status()) + return statuses + + def retrieve_ss_jobs(self) -> dict[str, str]: + """Retrieve the jobs from the server. + + Returns: + A dictionary of the statuses of any jobs that have not been successfully completed. + """ + # If no jobs then return empty dictionary + if not [sample for sample in self.samples if sample.job is not None]: + return {} + + statuses = {} + waiting_samples = [ + sample for sample in self.samples if not hasattr(sample, "probabilities") + ] + for sample in tqdm(waiting_samples, "Retrieving jobs"): + if sample.job is None: + continue + job = self._service.get_job(sample.job) + if job.status() in job.NON_TERMINAL_STATES + job.UNSUCCESSFUL_STATES: + statuses[job.job_id()] = job.status() + else: + sample.probabilities = self._process_device_counts(job.counts(0)) + + return statuses def sample_circuits_with_simulator( self, target: cirq.SimulatorBase, shots: int = 10_000 # type: ignore [type-arg] @@ -309,6 +319,55 @@ def sample_circuits_with_simulator( sample.probabilities = self._state_probs_to_dict(output_probabilities) + def collect_data(self, force: bool = False) -> bool: + """Collect the data from the samples and process it into the :attr:`raw_data` attribute. + + If the data is successfully stored in the :attr:`raw_data` attribute then the function will + return :code:`True` + + If either not all jobs submitted to the server have completed, or not all samples have + probability results then no data will be saved in :attr:`raw_data` and the function will + return :code:`False`. This check can be overridden with :code:`force=True` in which case + only the samples which have probability results will be used to generate the results + dataframe. + + Args: + force: Whether to override the check that all data is present. Defaults to False. + + Raises: + RuntimeError: If :code:`force=True` but there are no samples with any data. + RuntimeError: If the experiment has not yet been run. + + Returns: + Whether the results dataframe has been successfully created. + """ + if not self.samples: + raise RuntimeError("The experiment has not yet ben run.") + + # Retrieve jobs from server (if needed) + outstanding_statuses = self.retrieve_ss_jobs() + if outstanding_statuses: + print( + f"Not all circuits have been sampled.\n" + f"Please wait and try again.\n" + f"Outstanding Superstaq jobs:\n{outstanding_statuses}" + ) + if not force: + return False + + completed_samples = [sample for sample in self.samples if hasattr(sample, "probabilities")] + + if not len(completed_samples) == len(self.samples): + print("Some samples do not have probability results") + if not force: + return False + + if len(completed_samples) == 0: + raise RuntimeError("Cannot force data collection when there are no completed samples.") + + self._raw_data = self.process_probabilities(completed_samples) + return True + @abstractmethod def build_circuits( self, @@ -327,22 +386,10 @@ def build_circuits( """ @abstractmethod - def process_probabilities(self) -> None: - """Processes the probabilities generated by sampling the circuits into the data structures - needed for analyzing the results. Uses the data saved in the :attr:`_samples` attribute and - saves the raw data in the :attr:`_raw_data` attribute ready to - be analyzed when the :meth:`analyse_results` method is called. - - .. note:: - - Any subclasses should call this base method. - - Raises: - RuntimeError: If not all circuits have been sampled. + def process_probabilities(self, samples: Sequence[Sample]) -> pd.DataFrame: + """Processes the probabilities generated by sampling the circuits into a data frame + needed for analyzing the results. """ - missing_data = [sample for sample in self.samples if not hasattr(sample, "probabilities")] - if missing_data: - raise RuntimeError("Not all circuits have been successfully sampled.") @abstractmethod def plot_results(self) -> None: From a8ba683700aece9954e245050629f0618dfcfa90 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 19 Jul 2024 15:05:11 +0100 Subject: [PATCH 06/32] Fix tests --- .../supermarq/qcvv/base_experiment.py | 13 +- .../supermarq/qcvv/base_experiment_test.py | 351 +++++++++++++----- 2 files changed, 256 insertions(+), 108 deletions(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index 12ef079c8..84d1ca58f 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -24,6 +24,7 @@ import cirq import numpy as np import pandas as pd +from cirq_superstaq.job import Job from cirq_superstaq.service import Service from general_superstaq.superstaq_exceptions import SuperstaqServerException from tqdm.notebook import tqdm @@ -256,7 +257,7 @@ def submit_ss_jobs( ) sample.job = job.job_id() except SuperstaqServerException as error: - print( + warnings.warn( "The following error ocurred when submitting the jobs to the server and not\n" "all jobs have been submitted. If this is a timeout or limit based error\n" "consider running `submit_ss_jobs(args)` again to continue submitting\n" @@ -295,7 +296,7 @@ def retrieve_ss_jobs(self) -> dict[str, str]: if sample.job is None: continue job = self._service.get_job(sample.job) - if job.status() in job.NON_TERMINAL_STATES + job.UNSUCCESSFUL_STATES: + if job.status() in Job.NON_TERMINAL_STATES + Job.UNSUCCESSFUL_STATES: statuses[job.job_id()] = job.status() else: sample.probabilities = self._process_device_counts(job.counts(0)) @@ -341,15 +342,15 @@ def collect_data(self, force: bool = False) -> bool: Returns: Whether the results dataframe has been successfully created. """ - if not self.samples: + if not self._samples: raise RuntimeError("The experiment has not yet ben run.") # Retrieve jobs from server (if needed) outstanding_statuses = self.retrieve_ss_jobs() if outstanding_statuses: print( - f"Not all circuits have been sampled.\n" - f"Please wait and try again.\n" + "Not all circuits have been sampled.\n" + "Please wait and try again.\n" f"Outstanding Superstaq jobs:\n{outstanding_statuses}" ) if not force: @@ -358,7 +359,7 @@ def collect_data(self, force: bool = False) -> bool: completed_samples = [sample for sample in self.samples if hasattr(sample, "probabilities")] if not len(completed_samples) == len(self.samples): - print("Some samples do not have probability results") + print("Some samples do not have probability results.") if not force: return False diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index e1a498af3..e4ff2aee8 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -24,7 +24,7 @@ import numpy as np import pandas as pd import pytest -from general_superstaq.superstaq_exceptions import SuperstaqException +from general_superstaq.superstaq_exceptions import SuperstaqServerException from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample @@ -91,9 +91,8 @@ def test_empty_samples_error(abc_experiment: BenchmarkingExperiment) -> None: def test_run_results_overwrite_warning(abc_experiment: BenchmarkingExperiment) -> None: - abc_experiment._results = pd.DataFrame([{"example": 1234}]) + abc_experiment._samples = [Sample(circuit=MagicMock(), data={})] abc_experiment.build_circuits = MagicMock() - abc_experiment.run_ss_jobs = MagicMock() abc_experiment.sample_circuits_with_simulator = MagicMock() abc_experiment.process_probabilities = MagicMock() @@ -109,12 +108,10 @@ def test_run_with_bad_layers(abc_experiment: BenchmarkingExperiment) -> None: def test_run_local(abc_experiment: BenchmarkingExperiment) -> None: abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) - abc_experiment.run_ss_jobs = (mock_run_ss_jobs := MagicMock()) + abc_experiment.submit_ss_jobs = (mock_submit_ss_jobs := MagicMock()) abc_experiment.sample_circuits_with_simulator = ( mock_sample_circuits_with_simulator := MagicMock() ) - abc_experiment.process_probabilities = (mock_process_probabilities := MagicMock()) - abc_experiment.run(50, [1, 50, 100], shots=50) mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) @@ -124,17 +121,15 @@ def test_run_local(abc_experiment: BenchmarkingExperiment) -> None: assert call_args[1] == 50 assert isinstance(call_args[0], cirq.Simulator) # Test simulated on a default target - mock_process_probabilities.assert_called_once_with() - mock_run_ss_jobs.assert_not_called() + mock_submit_ss_jobs.assert_not_called() def test_run_local_defined_sim(abc_experiment: BenchmarkingExperiment) -> None: abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) - abc_experiment.run_ss_jobs = (mock_run_ss_jobs := MagicMock()) + abc_experiment.submit_ss_jobs = (mock_submit_ss_jobs := MagicMock()) abc_experiment.sample_circuits_with_simulator = ( mock_sample_circuits_with_simulator := MagicMock() ) - abc_experiment.process_probabilities = (mock_process_probabilities := MagicMock()) abc_experiment.run( 50, [1, 50, 100], shots=50, target=(target_sim := cirq.DensityMatrixSimulator()) @@ -147,26 +142,22 @@ def test_run_local_defined_sim(abc_experiment: BenchmarkingExperiment) -> None: assert call_args[1] == 50 assert call_args[0] == target_sim # Test simulated on the given target - mock_process_probabilities.assert_called_once_with() - mock_run_ss_jobs.assert_not_called() + mock_submit_ss_jobs.assert_not_called() def test_run_on_ss_server(abc_experiment: BenchmarkingExperiment) -> None: abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) - abc_experiment.run_ss_jobs = (mock_run_ss_jobs := MagicMock()) + abc_experiment.submit_ss_jobs = (mock_submit_ss_jobs := MagicMock()) abc_experiment.sample_circuits_with_simulator = ( mock_sample_circuits_with_simulator := MagicMock() ) - abc_experiment.process_probabilities = (mock_process_probabilities := MagicMock()) - abc_experiment.run(50, [1, 50, 100], shots=50, target="example_ss_target") mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) mock_sample_circuits_with_simulator.assert_not_called() - mock_process_probabilities.assert_called_once_with() - mock_run_ss_jobs.assert_called_once_with("example_ss_target", 50, False) + mock_submit_ss_jobs.assert_called_once_with("example_ss_target", 50, False) def test_run_with_simulator( @@ -193,110 +184,100 @@ def test_run_with_simulator( assert sample_circuits[1].probabilities == {"00": 0.0, "01": 1.0, "10": 0.0, "11": 0.0} -def test_run_ss_jobs(abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample]) -> None: +def test_submit_ss_jobs( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: abc_experiment._samples = sample_circuits - with patch("supermarq.qcvv.base_experiment.Service") as mock_service: - mock_service().create_job.return_value = MagicMock( - counts=MagicMock( - return_value=[ - {"00": 5, "01": 5, "10": 5, "11": 10}, - {"00": 5, "01": 5, "10": 5, "11": 10}, - ] - ) - ) - mock_service().target_info.return_value = {} - abc_experiment.run_ss_jobs("example_target", shots=100) + abc_experiment._service = (mock_service := MagicMock()) + mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] - for sample in sample_circuits: - assert sample.probabilities == {"00": 0.2, "01": 0.2, "10": 0.2, "11": 0.4} + mock_service().target_info.return_value = {} + abc_experiment.submit_ss_jobs("example_target", shots=100) - mock_service().create_job.assert_called_once_with( - [sample.circuit for sample in sample_circuits], - target="example_target", - method=None, - repetitions=100, + mock_service.create_job.assert_has_calls( + [ + call( + sample_circuits[0].circuit, + target="example_target", + method=None, + repetitions=100, + ), + call( + sample_circuits[1].circuit, + target="example_target", + method=None, + repetitions=100, + ), + ], + any_order=True, ) -def test_run_ss_jobs_not_all_samples( +def test_submit_ss_jobs_dry_run( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - abc_experiment._samples[0].probabilities = {"example": 0.7} - with patch("supermarq.qcvv.base_experiment.Service") as mock_service: - mock_service().create_job.return_value = MagicMock( - counts=MagicMock( - return_value=[ - {"00": 5, "01": 5, "10": 5, "11": 10}, - {"00": 5, "01": 5, "10": 5, "11": 10}, - ] - ) - ) - mock_service().target_info.return_value = {} - abc_experiment.run_ss_jobs("example_target", shots=100, all_samples=False) - - assert sample_circuits[1].probabilities == {"00": 0.2, "01": 0.2, "10": 0.2, "11": 0.4} - - mock_service().create_job.assert_called_once_with( - [sample_circuits[1].circuit], - target="example_target", - method=None, - repetitions=100, + abc_experiment._service = (mock_service := MagicMock()) + mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] + + mock_service().target_info.return_value = {} + abc_experiment.submit_ss_jobs("example_target", shots=100, dry_run=True) + + mock_service.create_job.assert_has_calls( + [ + call( + sample_circuits[0].circuit, + target="example_target", + method="dry-run", + repetitions=100, + ), + call( + sample_circuits[1].circuit, + target="example_target", + method="dry-run", + repetitions=100, + ), + ], + any_order=True, ) -def test_run_ss_jobs_dry_run_partitioning( +def test_submit_ss_jobs_job_already_has_id( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - with patch("supermarq.qcvv.base_experiment.Service") as mock_service: - mock_service().create_job.return_value = MagicMock( - counts=MagicMock( - return_value=[ - {"00": 5, "01": 5, "10": 5, "11": 10}, - {"00": 5, "01": 5, "10": 5, "11": 10}, - ] - ) - ) - mock_service().target_info.return_value = {"max_experiments": 1} - abc_experiment.run_ss_jobs("example_target", shots=100, dry_run=True) + sample_circuits[0].job = "example_job_id" + abc_experiment._service = (mock_service := MagicMock()) + mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] - for sample in sample_circuits: - assert sample.probabilities == {"00": 0.2, "01": 0.2, "10": 0.2, "11": 0.4} + mock_service().target_info.return_value = {} + abc_experiment.submit_ss_jobs("example_target", shots=100, dry_run=True) - mock_service().create_job.assert_has_calls( + mock_service.create_job.assert_has_calls( [ call( - [sample_circuits[0].circuit], + sample_circuits[1].circuit, target="example_target", method="dry-run", repetitions=100, ), - call().counts(), - call( - [sample_circuits[1].circuit], - target="example_target", - method="dry-run", - repetitions=100, - ), - call().counts(), - ] + ], + any_order=True, ) -def test_run_ss_jobs_with_exception( +def test_submit_ss_jobs_with_exception( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - with patch("supermarq.qcvv.base_experiment.Service") as mock_service: - mock_service().create_job.return_value = MagicMock( - counts=MagicMock(side_effect=SuperstaqException("example_exception")) - ) - with pytest.warns(UserWarning): - abc_experiment.run_ss_jobs("example_target", shots=100, dry_run=True) + abc_experiment._service = (mock_service := MagicMock()) + + mock_service.create_job.side_effect = SuperstaqServerException("example_exception") + with pytest.warns(UserWarning): + abc_experiment.submit_ss_jobs("example_target", shots=100, dry_run=True) def test_state_probs_to_dict(abc_experiment: BenchmarkingExperiment) -> None: @@ -350,6 +331,20 @@ def test_interleave_circuit() -> None: ) +def test_sample_statuses( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + sample_circuits[0].job = "example_job_id" + abc_experiment._service = (mock_service := MagicMock()) + mock_service.get_job.return_value.status.side_effect = ["example_status"] + + statuses = abc_experiment.sample_statuses() + assert statuses == ["example_status", None] + + mock_service.get_job.assert_called_once_with("example_job_id") + + def test_clean_circuit( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: @@ -360,24 +355,176 @@ def test_clean_circuit( assert sample.circuit[-1] == cirq.Moment(cirq.measure(*sample.circuit.all_qubits())) -def test_process_probabilities( +def test_process_device_counts(abc_experiment: BenchmarkingExperiment) -> None: + counts = { + "00": 20, + "01": 5, + "11": 10, + } + probs = abc_experiment._process_device_counts(counts) + + assert probs == {"00": 20 / 35, "01": 5 / 35, "10": 0.0, "11": 10 / 35} + + +def test_retrieve_ss_jobs_not_all_submitted( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + abc_experiment._samples[0].job = "example_job_id" + mock_job_1 = MagicMock() + mock_job_1.status.return_value = "Queued" + mock_job_1.job_id.return_value = "example_job_id" + + abc_experiment._service = MagicMock() + abc_experiment._service.get_job.return_value = mock_job_1 + + statuses = abc_experiment.retrieve_ss_jobs() + + abc_experiment._service.get_job.assert_called_once_with("example_job_id") + + assert statuses == {"example_job_id": "Queued"} + assert not hasattr(sample_circuits[0], "probabilities") + assert not hasattr(sample_circuits[1], "probabilities") + + +def test_retrieve_ss_jobs_nothing_to_retrieve( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + statuses = abc_experiment.retrieve_ss_jobs() + assert statuses == {} + + +def test_retrieve_ss_jobs_all_submitted( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + abc_experiment._samples = sample_circuits + abc_experiment._samples[0].job = "example_job_id_1" + mock_job_1 = MagicMock() + mock_job_1.status.return_value = "Queued" + mock_job_1.job_id.return_value = "example_job_id_1" + + abc_experiment._samples[1].job = "example_job_id_2" + mock_job_2 = MagicMock() + mock_job_2.status.return_value = "Done" + mock_job_2.job_id.return_value = "example_job_id_2" + mock_job_2.counts.return_value = {"00": 5, "11": 10} + + abc_experiment._service = MagicMock() + abc_experiment._service.get_job.side_effect = [mock_job_1, mock_job_2] + + statuses = abc_experiment.retrieve_ss_jobs() + + # Check get job calls + abc_experiment._service.get_job.assert_has_calls( + [call("example_job_id_1"), call("example_job_id_2")] + ) + + # Check counts call + mock_job_2.counts.assert_called_once_with(0) + + assert statuses == {"example_job_id_1": "Queued"} + + # Check probabilities correctly updated + assert sample_circuits[1].probabilities == {"00": 5 / 15, "01": 0.0, "10": 0.0, "11": 10 / 15} + assert not hasattr(sample_circuits[0], "probabilities") + + +def test_collect_data_no_samples(abc_experiment: BenchmarkingExperiment) -> None: + with pytest.raises(RuntimeError, match="The experiment has not yet ben run."): + abc_experiment.collect_data() + + +def test_collect_data_no_jobs_to_retrieve( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + sample_circuits[0].probabilities = {"00": 1.0, "10": 0.0, "01": 0.0, "11": 0.0} + sample_circuits[1].probabilities = {"00": 0.0, "10": 0.0, "01": 0.0, "11": 1.0} + abc_experiment._samples = sample_circuits + abc_experiment.process_probabilities = MagicMock() + + assert abc_experiment.collect_data() + abc_experiment.process_probabilities.assert_called_once_with(sample_circuits) + + +def test_collect_data_no_jobs_to_retrieve_not_all_probabilities( + abc_experiment: BenchmarkingExperiment, + sample_circuits: list[Sample], + capfd: pytest.CaptureFixture[str], +) -> None: + sample_circuits[0].probabilities = {"00": 1.0, "10": 0.0, "01": 0.0, "11": 0.0} + abc_experiment._samples = sample_circuits + abc_experiment.process_probabilities = MagicMock() + + assert not abc_experiment.collect_data() + out, _ = capfd.readouterr() + assert out == "Some samples do not have probability results.\n" + abc_experiment.process_probabilities.assert_not_called() + + +def test_collect_data_no_jobs_to_retrieve_not_all_probabilities_forced( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: + sample_circuits[0].probabilities = {"00": 1.0, "10": 0.0, "01": 0.0, "11": 0.0} abc_experiment._samples = sample_circuits - with pytest.raises(RuntimeError, match="Not all circuits have been successfully sampled."): - abc_experiment.process_probabilities() + abc_experiment.process_probabilities = MagicMock() + + assert abc_experiment.collect_data(force=True) + abc_experiment.process_probabilities.assert_called_once_with([sample_circuits[0]]) -def test_run_ss_jobs_counts_not_list( +def test_collect_data_cannot_force( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - with patch("supermarq.qcvv.base_experiment.Service") as mock_service: - mock_service().create_job.return_value = MagicMock( - counts=MagicMock(return_value={"00": 5, "01": 5, "10": 5, "11": 10}) - ) - mock_service().target_info.return_value = {} - with pytest.raises( - TypeError, match="Expected the counts returned from the `job` to be a list." - ): - abc_experiment.run_ss_jobs("example_target", shots=100) + abc_experiment.process_probabilities = MagicMock() + + with pytest.raises( + RuntimeError, match="Cannot force data collection when there are no completed samples." + ): + abc_experiment.collect_data(force=True) + + abc_experiment.process_probabilities.assert_not_called() + + +def test_collect_data_outstanding_jobs( + abc_experiment: BenchmarkingExperiment, + sample_circuits: list[Sample], + capfd: pytest.CaptureFixture[str], +) -> None: + abc_experiment._samples = sample_circuits + abc_experiment.process_probabilities = MagicMock() + abc_experiment.retrieve_ss_jobs = MagicMock(return_value={"example_id": "some_status"}) + assert not abc_experiment.collect_data() + out, _ = capfd.readouterr() + assert out == ( + "Not all circuits have been sampled.\n" + "Please wait and try again.\n" + "Outstanding Superstaq jobs:\n" + "{'example_id': 'some_status'}\n" + ) + abc_experiment.process_probabilities.assert_not_called() + + +def test_collect_data_outstanding_jobs_force( + abc_experiment: BenchmarkingExperiment, + sample_circuits: list[Sample], + capfd: pytest.CaptureFixture[str], +) -> None: + abc_experiment._samples = sample_circuits + abc_experiment.process_probabilities = MagicMock(return_value=pd.DataFrame([{"data": 1.0}])) + abc_experiment.samples[0].probabilities = {"00": 1.0, "10": 0.0, "01": 0.0, "11": 0.0} + abc_experiment.retrieve_ss_jobs = MagicMock(return_value={"example_id": "some_status"}) + assert abc_experiment.collect_data(force=True) + out, _ = capfd.readouterr() + assert out == ( + "Not all circuits have been sampled.\n" + "Please wait and try again.\n" + "Outstanding Superstaq jobs:\n" + "{'example_id': 'some_status'}\n" + "Some samples do not have probability results.\n" + ) + + abc_experiment.process_probabilities.assert_called_once_with([abc_experiment.samples[0]]) + + pd.testing.assert_frame_equal(pd.DataFrame([{"data": 1.0}]), abc_experiment.raw_data) From 246c58d1687265ec4b2606ab9d3d15239bb50f87 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 19 Jul 2024 15:06:45 +0100 Subject: [PATCH 07/32] Remove qcvv from cirq docs --- docs/source/index.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/source/index.rst b/docs/source/index.rst index 3ead159bc..7f22e1b2b 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -62,7 +62,6 @@ Learn more about Superstaq `here `_. To co apps/max_sharpe_ratio_optimization apps/dfe/dfe apps/aces/aces - apps/qcvv/qcvv .. toctree:: :maxdepth: 1 From 3eac549e592ca8b384bd2e3a83c61342f115a691 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 19 Jul 2024 15:12:43 +0100 Subject: [PATCH 08/32] Patch css Service in tests --- supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index e4ff2aee8..aba1b104d 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -37,7 +37,8 @@ def patch_tqdm() -> None: @pytest.fixture @patch.multiple(BenchmarkingExperiment, __abstractmethods__=set()) def abc_experiment() -> BenchmarkingExperiment: - return BenchmarkingExperiment(num_qubits=2) # type: ignore[abstract] + with patch("cirq_superstaq.service.Service"): + return BenchmarkingExperiment(num_qubits=2) # type: ignore[abstract] @pytest.fixture From 9d8e8449431ef938369a42d54be25db7934df62b Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 19 Jul 2024 15:24:44 +0100 Subject: [PATCH 09/32] Fix import css --- supermarq-benchmarks/supermarq/qcvv/base_experiment.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index 84d1ca58f..ee9a855ec 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -22,10 +22,9 @@ from typing import Any, NamedTuple import cirq +import cirq_superstaq as css import numpy as np import pandas as pd -from cirq_superstaq.job import Job -from cirq_superstaq.service import Service from general_superstaq.superstaq_exceptions import SuperstaqServerException from tqdm.notebook import tqdm @@ -131,7 +130,7 @@ def __init__( self._samples: Sequence[Sample] | None = None """The attribute to store the experimental samples in.""" - self._service: Service = Service(**kwargs) + self._service: css.service.Service = css.service.Service(**kwargs) @property def results(self) -> NamedTuple: @@ -296,7 +295,7 @@ def retrieve_ss_jobs(self) -> dict[str, str]: if sample.job is None: continue job = self._service.get_job(sample.job) - if job.status() in Job.NON_TERMINAL_STATES + Job.UNSUCCESSFUL_STATES: + if job.status() in css.job.Job.NON_TERMINAL_STATES + css.job.Job.UNSUCCESSFUL_STATES: statuses[job.job_id()] = job.status() else: sample.probabilities = self._process_device_counts(job.counts(0)) From 26af2532b50b07396caea22420a906b8c3f416d7 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Mon, 22 Jul 2024 15:17:20 +0100 Subject: [PATCH 10/32] fix: fix tests and notebook --- .../examples/qcvv/qcvv_css.ipynb | 88 +++++++++++-------- .../supermarq/qcvv/base_experiment.py | 36 ++++---- .../supermarq/qcvv/base_experiment_test.py | 22 ++--- 3 files changed, 83 insertions(+), 63 deletions(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index 8c5269caa..31feca71e 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -29,11 +29,21 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "from cirq_superstaq.qcvv.base_experiment import BenchmarkingExperiment\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample\n", "from collections.abc import Sequence\n", "from typing import Iterable, NamedTuple\n", "from tqdm.contrib.itertools import product\n", @@ -47,9 +57,6 @@ "import matplotlib.pyplot as plt\n", "\n", "\n", - "from cirq_superstaq.qcvv.base_experiment import Sample\n", - "\n", - "\n", "class NaiveExperimentResult(NamedTuple):\n", " gate_fidelity: float\n", " gate_error: float\n", @@ -69,13 +76,12 @@ " samples.append(Sample(circuit=circuit, data={\"depth\": depth}))\n", " return samples\n", "\n", - " def process_probabilities(self) -> None:\n", + " def process_probabilities(self, samples) -> None:\n", " \"\"\"Copy the data and observed probabilities into a pandas DataFrame.\"\"\"\n", - " super().process_probabilities()\n", " records = []\n", - " for sample in self.samples:\n", + " for sample in samples:\n", " records.append({**sample.data, **sample.probabilities})\n", - " self._raw_data = pd.DataFrame(records)\n", + " return pd.DataFrame(records)\n", "\n", " def analyse_results(self, plot_results: bool = True) -> NamedTuple:\n", " \"\"\"To analyse the results to fit a simple exponential decay. This can be done easily\n", @@ -104,7 +110,9 @@ "\n", " x = np.linspace(0, max(self.raw_data.depth))\n", " y = 0.5 * self.results.gate_fidelity**x + 0.5\n", - " axs.plot(x, y)" + " axs.plot(x, y)\n", + " axs.set_xlabel(\"Circuit depth\")\n", + " axs.set_ylabel(\"Probability of ground state\")" ] }, { @@ -112,24 +120,24 @@ "metadata": {}, "source": [ "To test this basic experiment, we use a depolarising noise model and a density matrix simulator.\n", - "Note that if we use a single qubit depolarising channel with rate $p$ this will result in a bit-flip\n", + "Note that if we use a single qubit depolarising channel with pauli error rate $p$ this will result in an \n", "error with probability of $4p/3$." ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b9bb64d74a964b398bae86e0a7725c55", + "model_id": "daa813aa1cca4c11a1cb644983948937", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/200 [00:00" ] @@ -171,11 +189,9 @@ } ], "source": [ - "noise = cirq.DepolarizingChannel(p=0.01)\n", - "simulator = cirq.DensityMatrixSimulator(noise=noise)\n", - "experiment = NaiveExperiment()\n", - "experiment.run(50, [1, 10, 50, 100], target=simulator)\n", - "experiment.analyse_results(plot_results=True)" + "if experiment.collect_data():\n", + " results = experiment.analyse_results(plot_results=True)\n", + " print(results)" ] }, { @@ -187,27 +203,27 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.009973840110814286\n" + "0.009916947688635214\n" ] } ], "source": [ - "channel_rate = 3 / 4 * experiment.results.gate_error\n", - "print(channel_rate)" + "pauli_error_rate = 3 / 4 * experiment.results.gate_error\n", + "print(pauli_error_rate)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Which agrees very closely with our channel rate of $0.01$" + "Which agrees very closely with our channel which we set up with $p=0.01$" ] } ], diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index ee9a855ec..f898c94de 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -14,6 +14,7 @@ """ from __future__ import annotations +import pprint import warnings from abc import ABC, abstractmethod from collections.abc import Iterable, Sequence @@ -181,7 +182,8 @@ def run( layers: Iterable[int], target: cirq.SimulatorBase | str | None = None, # type: ignore [type-arg] shots: int = 10_000, - dry_run: bool = False, + method: str | None = None, + target_options: dict[str, Any] | None = None, ) -> None: """Run the benchmarking experiment and analyse the results. @@ -191,8 +193,9 @@ def run( target: Either a local :class:`~cirq.SimulatorBase` to use or the name of a Superstaq target. If None then a local simulator is used. Defaults to None. shots: The number of shots to sample. Defaults to 10,000. - dry_run: If the circuits are submitted to the Superstaq server then - using :code:`dry-run=True` will run the circuits in :code:`dry-run` mode. + method: Optional method to use on the Superstaq device. Defaults to None corresponding + to normal running. + target_options: Optional configuration dictionary passed when submitting the job. """ if self._samples is not None: warnings.warn("Existing results will be overwritten.") @@ -207,7 +210,7 @@ def run( target = cirq.Simulator() if isinstance(target, str): - self.submit_ss_jobs(target, shots, dry_run) + self.submit_ss_jobs(target, shots, method, **(target_options or {})) else: self.sample_circuits_with_simulator(target, shots) @@ -225,7 +228,8 @@ def submit_ss_jobs( self, target: str, shots: int = 10_000, - dry_run: bool = False, + method: str | None = None, + **target_options: Any, ) -> None: """Submit the circuit samples to the desired target device and store the resulting probabilities. @@ -237,22 +241,20 @@ def submit_ss_jobs( Args: target: The name of the target device. shots: The number of shots to use. Defaults to 10,000 - dry_run: Whether to perform a dry run on the Superstaq server instead of submitting - to the real device. + method: Optional method to use on the Superstaq device. Defaults to None corresponding + to normal running. + target_options: Optional configuration kwargs passed when submitting the job. """ - - # Configure dry-runs - if dry_run: - method = "dry-run" - else: - method = None - for sample in tqdm(self.samples): if sample.job is not None: continue try: job = self._service.create_job( - sample.circuit, target=target, method=method, repetitions=shots + sample.circuit, + target=target, + method=method, + repetitions=shots, + **target_options, ) sample.job = job.job_id() except SuperstaqServerException as error: @@ -348,9 +350,9 @@ def collect_data(self, force: bool = False) -> bool: outstanding_statuses = self.retrieve_ss_jobs() if outstanding_statuses: print( - "Not all circuits have been sampled.\n" + "Not all circuits have been sampled. " "Please wait and try again.\n" - f"Outstanding Superstaq jobs:\n{outstanding_statuses}" + f"Outstanding Superstaq jobs:\n{pprint.pformat(outstanding_statuses)}" ) if not force: return False diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index aba1b104d..fb33f1465 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -152,13 +152,17 @@ def test_run_on_ss_server(abc_experiment: BenchmarkingExperiment) -> None: abc_experiment.sample_circuits_with_simulator = ( mock_sample_circuits_with_simulator := MagicMock() ) - abc_experiment.run(50, [1, 50, 100], shots=50, target="example_ss_target") + abc_experiment.run( + 50, [1, 50, 100], shots=50, target="example_ss_target", target_options={"some": "options"} + ) mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) mock_sample_circuits_with_simulator.assert_not_called() - mock_submit_ss_jobs.assert_called_once_with("example_ss_target", 50, False) + mock_submit_ss_jobs.assert_called_once_with( + "example_ss_target", 50, None, **{"some": "options"} + ) def test_run_with_simulator( @@ -224,7 +228,7 @@ def test_submit_ss_jobs_dry_run( mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] mock_service().target_info.return_value = {} - abc_experiment.submit_ss_jobs("example_target", shots=100, dry_run=True) + abc_experiment.submit_ss_jobs("example_target", shots=100, method="dry-run") mock_service.create_job.assert_has_calls( [ @@ -255,14 +259,14 @@ def test_submit_ss_jobs_job_already_has_id( mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] mock_service().target_info.return_value = {} - abc_experiment.submit_ss_jobs("example_target", shots=100, dry_run=True) + abc_experiment.submit_ss_jobs("example_target", shots=100, method="example_method") mock_service.create_job.assert_has_calls( [ call( sample_circuits[1].circuit, target="example_target", - method="dry-run", + method="example_method", repetitions=100, ), ], @@ -278,7 +282,7 @@ def test_submit_ss_jobs_with_exception( mock_service.create_job.side_effect = SuperstaqServerException("example_exception") with pytest.warns(UserWarning): - abc_experiment.submit_ss_jobs("example_target", shots=100, dry_run=True) + abc_experiment.submit_ss_jobs("example_target", shots=100) def test_state_probs_to_dict(abc_experiment: BenchmarkingExperiment) -> None: @@ -499,8 +503,7 @@ def test_collect_data_outstanding_jobs( assert not abc_experiment.collect_data() out, _ = capfd.readouterr() assert out == ( - "Not all circuits have been sampled.\n" - "Please wait and try again.\n" + "Not all circuits have been sampled. Please wait and try again.\n" "Outstanding Superstaq jobs:\n" "{'example_id': 'some_status'}\n" ) @@ -519,8 +522,7 @@ def test_collect_data_outstanding_jobs_force( assert abc_experiment.collect_data(force=True) out, _ = capfd.readouterr() assert out == ( - "Not all circuits have been sampled.\n" - "Please wait and try again.\n" + "Not all circuits have been sampled. Please wait and try again.\n" "Outstanding Superstaq jobs:\n" "{'example_id': 'some_status'}\n" "Some samples do not have probability results.\n" From d1072766fe78671a1eeb3efa199bf4ca3c808f0b Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Mon, 22 Jul 2024 15:26:54 +0100 Subject: [PATCH 11/32] fix: add seaborn to requirements --- supermarq-benchmarks/requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/supermarq-benchmarks/requirements.txt b/supermarq-benchmarks/requirements.txt index f47df2aa7..231b57940 100644 --- a/supermarq-benchmarks/requirements.txt +++ b/supermarq-benchmarks/requirements.txt @@ -1,3 +1,4 @@ cirq-superstaq~=0.5.20 qiskit-superstaq~=0.5.20 scikit-learn>=1.0 +seaborn>=0.13.2 From 5859d69062df80ab39009f17b0e47d65405075f2 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Mon, 22 Jul 2024 16:04:24 +0100 Subject: [PATCH 12/32] fix: add future annotations to notebook --- supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index 31feca71e..7dadcdc16 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -34,7 +34,8 @@ "outputs": [], "source": [ "%load_ext autoreload\n", - "%autoreload 2" + "%autoreload 2\n", + "from __future__ import annotations" ] }, { From 48aa81d4705aad0a35800de682046681e310c718 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Wed, 31 Jul 2024 11:59:32 +0100 Subject: [PATCH 13/32] Fixes following review --- cirq-superstaq/dev-requirements.txt | 2 +- cirq-superstaq/example-requirements.txt | 2 +- cirq-superstaq/requirements.txt | 2 +- docs/requirements.txt | 4 +- general-superstaq/dev-requirements.txt | 2 +- qiskit-superstaq/dev-requirements.txt | 2 +- qiskit-superstaq/requirements.txt | 2 +- supermarq-benchmarks/dev-requirements.txt | 2 +- .../examples/qcvv/qcvv_css.ipynb | 112 ++++++++++- supermarq-benchmarks/requirements.txt | 4 +- .../supermarq/qcvv/base_experiment.py | 150 +++++++------- .../supermarq/qcvv/base_experiment_test.py | 189 +++++++++--------- 12 files changed, 288 insertions(+), 185 deletions(-) diff --git a/cirq-superstaq/dev-requirements.txt b/cirq-superstaq/dev-requirements.txt index 11f71d387..35dfe073b 100644 --- a/cirq-superstaq/dev-requirements.txt +++ b/cirq-superstaq/dev-requirements.txt @@ -1 +1 @@ -checks-superstaq~=0.5.20 +checks-superstaq~=0.5.21 diff --git a/cirq-superstaq/example-requirements.txt b/cirq-superstaq/example-requirements.txt index 28ae6d1f5..4353b6159 100644 --- a/cirq-superstaq/example-requirements.txt +++ b/cirq-superstaq/example-requirements.txt @@ -1,2 +1,2 @@ notebook>=6.5.5 -qiskit-superstaq~=0.5.20 +qiskit-superstaq~=0.5.21 diff --git a/cirq-superstaq/requirements.txt b/cirq-superstaq/requirements.txt index 3fe4b9026..eb020f7d2 100644 --- a/cirq-superstaq/requirements.txt +++ b/cirq-superstaq/requirements.txt @@ -1,2 +1,2 @@ cirq-core>=1.0.0 -general-superstaq~=0.5.20 +general-superstaq~=0.5.21 diff --git a/docs/requirements.txt b/docs/requirements.txt index ae44a3717..4559682c9 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,2 +1,2 @@ -cirq-superstaq[dev]~=0.5.20 -qiskit-superstaq[dev]~=0.5.20 +cirq-superstaq[dev]~=0.5.21 +qiskit-superstaq[dev]~=0.5.21 diff --git a/general-superstaq/dev-requirements.txt b/general-superstaq/dev-requirements.txt index a7ac9feaa..582cbbfde 100644 --- a/general-superstaq/dev-requirements.txt +++ b/general-superstaq/dev-requirements.txt @@ -1,2 +1,2 @@ -checks-superstaq~=0.5.20 +checks-superstaq~=0.5.21 pyyaml>=6.0 diff --git a/qiskit-superstaq/dev-requirements.txt b/qiskit-superstaq/dev-requirements.txt index 11f71d387..35dfe073b 100644 --- a/qiskit-superstaq/dev-requirements.txt +++ b/qiskit-superstaq/dev-requirements.txt @@ -1 +1 @@ -checks-superstaq~=0.5.20 +checks-superstaq~=0.5.21 diff --git a/qiskit-superstaq/requirements.txt b/qiskit-superstaq/requirements.txt index 45fca081f..77ae6dfea 100644 --- a/qiskit-superstaq/requirements.txt +++ b/qiskit-superstaq/requirements.txt @@ -1,3 +1,3 @@ -general-superstaq~=0.5.20 +general-superstaq~=0.5.21 qiskit>=1.0.0 symengine~=0.11.0 diff --git a/supermarq-benchmarks/dev-requirements.txt b/supermarq-benchmarks/dev-requirements.txt index 11f71d387..35dfe073b 100644 --- a/supermarq-benchmarks/dev-requirements.txt +++ b/supermarq-benchmarks/dev-requirements.txt @@ -1 +1 @@ -checks-superstaq~=0.5.20 +checks-superstaq~=0.5.21 diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index 7dadcdc16..48fe4dc85 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -133,7 +133,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "daa813aa1cca4c11a1cb644983948937", + "model_id": "6a06de85b33b4d7a9115e384ab144d91", "version_major": 2, "version_minor": 0 }, @@ -147,7 +147,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a68bfc9c6dee4b92964ae329a77f6291", + "model_id": "2c32cfbbc36d4ae98ec0638c9369a2f5", "version_major": 2, "version_minor": 0 }, @@ -163,7 +163,7 @@ "noise = cirq.DepolarizingChannel(p=0.01)\n", "simulator = cirq.DensityMatrixSimulator(noise=noise)\n", "experiment = NaiveExperiment()\n", - "experiment.run(10, [10, 50, 100], shots=2000, target=simulator)" + "experiment.run_with_simulator(10, [10, 50, 100], shots=2000, target=simulator)" ] }, { @@ -175,12 +175,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "NaiveExperimentResult(gate_fidelity=0.9867774030818197, gate_error=0.013222596918180285)\n" + "NaiveExperimentResult(gate_fidelity=0.9863903425787091, gate_error=0.013609657421290944)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -211,7 +211,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.009916947688635214\n" + "0.010207243065968208\n" ] } ], @@ -226,6 +226,106 @@ "source": [ "Which agrees very closely with our channel which we set up with $p=0.01$" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could also run the same experiment on a device through Superstaq. In this case we use the \n", + "`run_on_device()` method instead, although for this example we use the Superstaq simulator device. \n", + "Note we also use the `force=True` option to overwrite our existing\n", + "results." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "13e532f86c9f46e692dfa638c593ea5c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Building circuits.: 0%| | 0/30 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if experiment.collect_data():\n", + " results = experiment.analyse_results(plot_results=True)\n", + " print(results)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As expected, since the Superstaq simulator is exact, we obtain a gate fidelity of 1.0" + ] } ], "metadata": { diff --git a/supermarq-benchmarks/requirements.txt b/supermarq-benchmarks/requirements.txt index 231b57940..be8279b1c 100644 --- a/supermarq-benchmarks/requirements.txt +++ b/supermarq-benchmarks/requirements.txt @@ -1,4 +1,4 @@ -cirq-superstaq~=0.5.20 -qiskit-superstaq~=0.5.20 +cirq-superstaq~=0.5.21 +qiskit-superstaq~=0.5.21 scikit-learn>=1.0 seaborn>=0.13.2 diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index f898c94de..5feb5b10e 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -18,7 +18,6 @@ import warnings from abc import ABC, abstractmethod from collections.abc import Iterable, Sequence -from copy import deepcopy from dataclasses import dataclass, field from typing import Any, NamedTuple @@ -42,8 +41,8 @@ class Sample: """The corresponding data about the circuit""" probabilities: dict[str, float] = field(init=False) """The probabilities of the computational basis states""" - job: str | None = None - """The superstaq job UUID corresponding to the sample. Defaults to None if no job is + job: css.Job | None = None + """The superstaq job corresponding to the sample. Defaults to None if no job is associated with the sample.""" @@ -176,44 +175,6 @@ def num_qubits(self) -> int: """ return len(self.qubits) - def run( - self, - num_circuits: int, - layers: Iterable[int], - target: cirq.SimulatorBase | str | None = None, # type: ignore [type-arg] - shots: int = 10_000, - method: str | None = None, - target_options: dict[str, Any] | None = None, - ) -> None: - """Run the benchmarking experiment and analyse the results. - - Args: - num_circuits: Number of circuits to run. - layers: An iterable of the different layer depths to use during the experiment. - target: Either a local :class:`~cirq.SimulatorBase` to use or the name of a Superstaq - target. If None then a local simulator is used. Defaults to None. - shots: The number of shots to sample. Defaults to 10,000. - method: Optional method to use on the Superstaq device. Defaults to None corresponding - to normal running. - target_options: Optional configuration dictionary passed when submitting the job. - """ - if self._samples is not None: - warnings.warn("Existing results will be overwritten.") - - if any(depth <= 0 for depth in layers): - raise ValueError("The `layers` iterator can only include positive values.") - - self._samples = self.build_circuits(num_circuits, layers) - self._clean_circuits() - - if target is None: - target = cirq.Simulator() - - if isinstance(target, str): - self.submit_ss_jobs(target, shots, method, **(target_options or {})) - else: - self.sample_circuits_with_simulator(target, shots) - def _clean_circuits(self) -> None: """Removes any terminal measurements that have been added to the circuit and replaces them with a single measurement of the whole system in the computational basis @@ -222,13 +183,44 @@ def _clean_circuits(self) -> None: if sample.circuit.has_measurements(): sample.circuit = cirq.drop_terminal_measurements(sample.circuit) # Add measurement of qubit state in computational basis. - sample.circuit += cirq.measure(sample.circuit.all_qubits()) + sample.circuit += cirq.measure(sorted(sample.circuit.all_qubits())) - def submit_ss_jobs( + def _prepare_experiment( + self, num_circuits: int, cycle_depths: Iterable[int], overwrite: bool = False + ) -> None: + """Prepares the circuits needed for the experiment + + Args: + num_circuits: Number of circuits to run. + cycle_depths: An iterable of the different layer depths to use during the experiment. + overwrite: Whether to force an experiment run even if there is existing data that would + be over written in the process. Defaults to False. + + Raises: + RuntimeError: If the experiment has already been run once and the `overwrite` argument + is not True + ValueError: If any of the cycle depths provided negative or zero. + """ + if self._samples is not None and not overwrite: + raise RuntimeError( + "This experiment already has existing data which would be overwritten by " + "rerunning the experiment. If this is the desired behavior set `overwrite=True`" + ) + + if any(depth <= 0 for depth in cycle_depths): + raise ValueError("The `cycle_depths` iterator can only include positive values.") + + self._samples = self.build_circuits(num_circuits, cycle_depths) + self._clean_circuits() + + def run_on_device( self, + num_circuits: int, + cycle_depths: Iterable[int], target: str, shots: int = 10_000, method: str | None = None, + overwrite: bool = False, **target_options: Any, ) -> None: """Submit the circuit samples to the desired target device and store the resulting @@ -239,24 +231,29 @@ def submit_ss_jobs( before saving the resulting probability distributions. Args: - target: The name of the target device. - shots: The number of shots to use. Defaults to 10,000 + num_circuits: Number of circuits to run. + cycle_depths: An iterable of the different layer depths to use during the experiment. + target: The name of a Superstaq target. + shots: The number of shots to sample. Defaults to 10,000. method: Optional method to use on the Superstaq device. Defaults to None corresponding to normal running. - target_options: Optional configuration kwargs passed when submitting the job. + target_options: Optional configuration dictionary passed when submitting the job. + overwrite: Whether to force an experiment run even if there is existing data that would + be over written in the process. Defaults to False. """ + self._prepare_experiment(num_circuits, cycle_depths, overwrite) + for sample in tqdm(self.samples): if sample.job is not None: continue try: - job = self._service.create_job( + sample.job = self._service.create_job( sample.circuit, target=target, method=method, repetitions=shots, **target_options, ) - sample.job = job.job_id() except SuperstaqServerException as error: warnings.warn( "The following error ocurred when submitting the jobs to the server and not\n" @@ -268,7 +265,7 @@ def submit_ss_jobs( def sample_statuses(self) -> list[str | None]: """Returns: - Get the statuses of the jobs associated with each sample. If no job is associated + The statuses of the jobs associated with each sample. If no job is associated with a sample then :code:`None` is listed instead. """ statuses: list[str | None] = [] @@ -276,7 +273,7 @@ def sample_statuses(self) -> list[str | None]: if sample.job is None: statuses.append(None) else: - statuses.append(self._service.get_job(sample.job).status()) + statuses.append(sample.job.status()) return statuses def retrieve_ss_jobs(self) -> dict[str, str]: @@ -296,30 +293,46 @@ def retrieve_ss_jobs(self) -> dict[str, str]: for sample in tqdm(waiting_samples, "Retrieving jobs"): if sample.job is None: continue - job = self._service.get_job(sample.job) - if job.status() in css.job.Job.NON_TERMINAL_STATES + css.job.Job.UNSUCCESSFUL_STATES: - statuses[job.job_id()] = job.status() + if ( + job_status := sample.job.status() + ) in css.job.Job.NON_TERMINAL_STATES + css.job.Job.UNSUCCESSFUL_STATES: + statuses[sample.job.job_id()] = job_status else: - sample.probabilities = self._process_device_counts(job.counts(0)) + sample.probabilities = self._process_device_counts(sample.job.counts(0)) return statuses - def sample_circuits_with_simulator( - self, target: cirq.SimulatorBase, shots: int = 10_000 # type: ignore [type-arg] + def run_with_simulator( + self, + num_circuits: int, + cycle_depths: Iterable[int], + target: cirq.SimulatorBase | None = None, # type: ignore [type-arg] + shots: int = 10_000, + overwrite: bool = False, ) -> None: """Use the local simulator to sample the circuits and store the resulting probabilities. Args: - target: The :class:`~cirq.SimulatorBase()` object to use for sampling the circuits with. - shots: The number of shots to use. Defaults to 10,000 + num_circuits: Number of circuits to run. + cycle_depths: An iterable of the different layer depths to use during the experiment. + target: A local :class:`~cirq.SimulatorBase` to use. If None then the default + :class:`cirq.Simulator` simulator is used. Defaults to None. + shots: The number of shots to sample. Defaults to 10,000. + overwrite: Whether to force an experiment run even if there is existing data that would + be over written in the process. Defaults to False. """ + self._prepare_experiment(num_circuits, cycle_depths, overwrite) + + if target is None: + target = cirq.Simulator() for sample in tqdm(self.samples, desc="Simulating circuits"): # Use transpose (.T) to reshape samples output from (n x 1) into (1 x n) - samples = target.sample(sample.circuit, repetitions=shots).values.T[0] - output_probabilities = np.bincount(samples, minlength=2**self.num_qubits) / len(samples) - - sample.probabilities = self._state_probs_to_dict(output_probabilities) + result = target.run(sample.circuit, repetitions=shots) + hist = result.histogram(key=cirq.measurement_key_name(sample.circuit)) + sample.probabilities = { + f"{i:0{self.num_qubits}b}": count / shots for i, count in hist.items() + } def collect_data(self, force: bool = False) -> bool: """Collect the data from the samples and process it into the :attr:`raw_data` attribute. @@ -374,14 +387,14 @@ def collect_data(self, force: bool = False) -> bool: def build_circuits( self, num_circuits: int, - layers: Iterable[int], + cycle_depths: Iterable[int], ) -> Sequence[Sample]: """Build a list of circuits required for the experiment. These circuits are stored in :class:`Sample` objects along with any additional data that is needed during the analysis. Args: num_circuits: Number of circuits to generate. - layers: An iterable of the different layer depths to use during the experiment. + cycle_depths: An iterable of the different cycle depths to use during the experiment. Returns: The list of circuit objects @@ -435,10 +448,11 @@ def _interleave_gate( Returns: A copy of the original circuit with the provided gate interleaved. """ - qubits = circuit.all_qubits() - interleaved_circuit = deepcopy(circuit) - for k in range(len(circuit) - int(not include_final), 0, -1): - interleaved_circuit.insert(k, gate(*qubits)) + qubits = sorted(circuit.all_qubits()) + interleaved_circuit = circuit.copy() + interleaved_circuit.batch_insert( + [(k, gate(*qubits)) for k in range(len(circuit) - int(not include_final), 0, -1)] + ) return interleaved_circuit def _process_device_counts(self, counts: dict[str, int]) -> dict[str, float]: diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index fb33f1465..626c9046c 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -21,6 +21,7 @@ from unittest.mock import MagicMock, call, patch import cirq +import cirq_superstaq as css import numpy as np import pandas as pd import pytest @@ -46,7 +47,7 @@ def sample_circuits() -> list[Sample]: qubits = cirq.LineQubit.range(2) return [ Sample( - circuit=cirq.Circuit(cirq.CZ(*qubits), cirq.MeasurementGate(num_qubits=2)(*qubits)), + circuit=cirq.Circuit(cirq.CZ(*qubits), cirq.CZ(*qubits), cirq.measure(*qubits)), data={"circuit": 1}, ), Sample(circuit=cirq.Circuit(cirq.CX(*qubits)), data={"circuit": 2}), @@ -91,114 +92,106 @@ def test_empty_samples_error(abc_experiment: BenchmarkingExperiment) -> None: _ = abc_experiment.samples -def test_run_results_overwrite_warning(abc_experiment: BenchmarkingExperiment) -> None: +def test_prepare_experiment_overwrite_error(abc_experiment: BenchmarkingExperiment) -> None: abc_experiment._samples = [Sample(circuit=MagicMock(), data={})] abc_experiment.build_circuits = MagicMock() - abc_experiment.sample_circuits_with_simulator = MagicMock() - abc_experiment.process_probabilities = MagicMock() - - print(abc_experiment._results) - with pytest.warns(UserWarning, match="Existing results will be overwritten."): - abc_experiment.run(100, [1, 50, 100]) - - -def test_run_with_bad_layers(abc_experiment: BenchmarkingExperiment) -> None: - with pytest.raises(ValueError, match="The `layers` iterator can only include positive values."): - abc_experiment.run(20, [0]) - - -def test_run_local(abc_experiment: BenchmarkingExperiment) -> None: - abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) - abc_experiment.submit_ss_jobs = (mock_submit_ss_jobs := MagicMock()) - abc_experiment.sample_circuits_with_simulator = ( - mock_sample_circuits_with_simulator := MagicMock() - ) - abc_experiment.run(50, [1, 50, 100], shots=50) - mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) + with pytest.raises( + RuntimeError, + match="This experiment already has existing data which would be overwritten by " + "rerunning the experiment. If this is the desired behavior set `overwrite=True`", + ): + abc_experiment._prepare_experiment(100, [1, 50, 100]) - mock_sample_circuits_with_simulator.assert_called_once() - call_args = mock_sample_circuits_with_simulator.call_args_list[0][0] - assert call_args[1] == 50 - assert isinstance(call_args[0], cirq.Simulator) # Test simulated on a default target - mock_submit_ss_jobs.assert_not_called() +def test_prepare_experiment_overwrite(abc_experiment: BenchmarkingExperiment) -> None: + abc_experiment._samples = [Sample(circuit=MagicMock(), data={})] + abc_experiment.build_circuits = MagicMock() + abc_experiment._clean_circuits = MagicMock() + abc_experiment._prepare_experiment(100, [1, 50, 100], overwrite=True) -def test_run_local_defined_sim(abc_experiment: BenchmarkingExperiment) -> None: - abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) - abc_experiment.submit_ss_jobs = (mock_submit_ss_jobs := MagicMock()) - abc_experiment.sample_circuits_with_simulator = ( - mock_sample_circuits_with_simulator := MagicMock() - ) + abc_experiment.build_circuits.assert_called_once_with(100, [1, 50, 100]) + abc_experiment._clean_circuits.assert_called_once_with() - abc_experiment.run( - 50, [1, 50, 100], shots=50, target=(target_sim := cirq.DensityMatrixSimulator()) - ) - mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) +def test_prepare_experiment_with_bad_layers(abc_experiment: BenchmarkingExperiment) -> None: + with pytest.raises( + ValueError, match="The `cycle_depths` iterator can only include positive values." + ): + abc_experiment._prepare_experiment(20, [0]) - mock_sample_circuits_with_simulator.assert_called_once() - call_args = mock_sample_circuits_with_simulator.call_args_list[0][0] - assert call_args[1] == 50 - assert call_args[0] == target_sim # Test simulated on the given target - mock_submit_ss_jobs.assert_not_called() +def test_run_with_simulator( + abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] +) -> None: + cirq.measurement_key_name = MagicMock() + abc_experiment._prepare_experiment = MagicMock() + abc_experiment._samples = sample_circuits + test_target = MagicMock() + mock_result = MagicMock() + mock_result.histogram.return_value = {0: 0, 1: 100, 2: 0, 3: 0} + test_target.run.return_value = mock_result + abc_experiment.run_with_simulator(10, [5, 10, 20], target=test_target, shots=100) -def test_run_on_ss_server(abc_experiment: BenchmarkingExperiment) -> None: - abc_experiment.build_circuits = (mock_build_circuits := MagicMock()) - abc_experiment.submit_ss_jobs = (mock_submit_ss_jobs := MagicMock()) - abc_experiment.sample_circuits_with_simulator = ( - mock_sample_circuits_with_simulator := MagicMock() - ) - abc_experiment.run( - 50, [1, 50, 100], shots=50, target="example_ss_target", target_options={"some": "options"} + # Test simulator calls + test_target.run.assert_has_calls( + [ + call(sample_circuits[0].circuit, repetitions=100), + call(sample_circuits[1].circuit, repetitions=100), + ], + any_order=True, ) - mock_build_circuits.assert_called_once_with(50, [1, 50, 100]) + # Test probabilities + assert sample_circuits[0].probabilities == {"00": 0.0, "01": 1.0, "10": 0.0, "11": 0.0} + assert sample_circuits[1].probabilities == {"00": 0.0, "01": 1.0, "10": 0.0, "11": 0.0} - mock_sample_circuits_with_simulator.assert_not_called() + abc_experiment._prepare_experiment.assert_called_once_with(10, [5, 10, 20], False) - mock_submit_ss_jobs.assert_called_once_with( - "example_ss_target", 50, None, **{"some": "options"} - ) - -def test_run_with_simulator( +def test_run_with_simulator_default_target( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: + cirq.measurement_key_name = MagicMock() + cirq.Simulator = (target := MagicMock()) # type: ignore [misc] + abc_experiment._prepare_experiment = MagicMock() abc_experiment._samples = sample_circuits - test_target = MagicMock(spec=cirq.Simulator) - test_target.sample = MagicMock( - return_value=MagicMock(values=np.ones(shape=(100, 1), dtype=np.int64)) - ) + mock_result = MagicMock() + mock_result.histogram.return_value = {0: 0, 1: 100, 2: 0, 3: 0} + target().run.return_value = mock_result - abc_experiment.sample_circuits_with_simulator(test_target, shots=100) + abc_experiment.run_with_simulator(10, [5, 10, 20], shots=100) # Test simulator calls - test_target.sample.assert_has_calls( + target().run.assert_has_calls( [ call(sample_circuits[0].circuit, repetitions=100), call(sample_circuits[1].circuit, repetitions=100), - ] + ], + any_order=True, ) # Test probabilities assert sample_circuits[0].probabilities == {"00": 0.0, "01": 1.0, "10": 0.0, "11": 0.0} assert sample_circuits[1].probabilities == {"00": 0.0, "01": 1.0, "10": 0.0, "11": 0.0} + abc_experiment._prepare_experiment.assert_called_once_with(10, [5, 10, 20], False) + -def test_submit_ss_jobs( +def test_run_on_device( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: - + abc_experiment._prepare_experiment = MagicMock() abc_experiment._samples = sample_circuits abc_experiment._service = (mock_service := MagicMock()) mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] mock_service().target_info.return_value = {} - abc_experiment.submit_ss_jobs("example_target", shots=100) + abc_experiment.run_on_device( + 10, [5, 10, 20], target="example_target", shots=100, overwrite=False, **{"some": "options"} + ) mock_service.create_job.assert_has_calls( [ @@ -207,28 +200,34 @@ def test_submit_ss_jobs( target="example_target", method=None, repetitions=100, + some="options", ), call( sample_circuits[1].circuit, target="example_target", method=None, repetitions=100, + some="options", ), ], any_order=True, ) + abc_experiment._prepare_experiment.assert_called_once_with(10, [5, 10, 20], False) + -def test_submit_ss_jobs_dry_run( +def test_run_on_device_dry_run( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: - + abc_experiment._prepare_experiment = MagicMock() abc_experiment._samples = sample_circuits abc_experiment._service = (mock_service := MagicMock()) mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] mock_service().target_info.return_value = {} - abc_experiment.submit_ss_jobs("example_target", shots=100, method="dry-run") + abc_experiment.run_on_device( + 10, [5, 10, 20], target="example_target", shots=100, method="dry-run" + ) mock_service.create_job.assert_has_calls( [ @@ -249,17 +248,19 @@ def test_submit_ss_jobs_dry_run( ) -def test_submit_ss_jobs_job_already_has_id( +def test_run_on_device_job_already_has_id( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: - + abc_experiment._prepare_experiment = MagicMock() abc_experiment._samples = sample_circuits - sample_circuits[0].job = "example_job_id" + sample_circuits[0].job = MagicMock() abc_experiment._service = (mock_service := MagicMock()) mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] mock_service().target_info.return_value = {} - abc_experiment.submit_ss_jobs("example_target", shots=100, method="example_method") + abc_experiment.run_on_device( + 10, [5, 10, 20], target="example_target", shots=100, method="example_method" + ) mock_service.create_job.assert_has_calls( [ @@ -274,15 +275,16 @@ def test_submit_ss_jobs_job_already_has_id( ) -def test_submit_ss_jobs_with_exception( +def test_run_on_device_with_exception( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits abc_experiment._service = (mock_service := MagicMock()) + abc_experiment._prepare_experiment = MagicMock() mock_service.create_job.side_effect = SuperstaqServerException("example_exception") with pytest.warns(UserWarning): - abc_experiment.submit_ss_jobs("example_target", shots=100) + abc_experiment.run_on_device(10, [5, 10, 20], target="example_target", shots=100) def test_state_probs_to_dict(abc_experiment: BenchmarkingExperiment) -> None: @@ -340,14 +342,13 @@ def test_sample_statuses( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - sample_circuits[0].job = "example_job_id" - abc_experiment._service = (mock_service := MagicMock()) - mock_service.get_job.return_value.status.side_effect = ["example_status"] + mock_job = MagicMock(spec=css.Job) + mock_job.status.return_value = "example_status" + sample_circuits[0].job = mock_job statuses = abc_experiment.sample_statuses() assert statuses == ["example_status", None] - - mock_service.get_job.assert_called_once_with("example_job_id") + mock_job.status.assert_called_once_with() def test_clean_circuit( @@ -375,18 +376,14 @@ def test_retrieve_ss_jobs_not_all_submitted( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - abc_experiment._samples[0].job = "example_job_id" + mock_job_1 = MagicMock() mock_job_1.status.return_value = "Queued" mock_job_1.job_id.return_value = "example_job_id" - - abc_experiment._service = MagicMock() - abc_experiment._service.get_job.return_value = mock_job_1 + abc_experiment._samples[0].job = mock_job_1 statuses = abc_experiment.retrieve_ss_jobs() - abc_experiment._service.get_job.assert_called_once_with("example_job_id") - assert statuses == {"example_job_id": "Queued"} assert not hasattr(sample_circuits[0], "probabilities") assert not hasattr(sample_circuits[1], "probabilities") @@ -404,27 +401,19 @@ def test_retrieve_ss_jobs_all_submitted( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - abc_experiment._samples[0].job = "example_job_id_1" - mock_job_1 = MagicMock() + mock_job_1 = MagicMock(spec=css.Job) mock_job_1.status.return_value = "Queued" mock_job_1.job_id.return_value = "example_job_id_1" + abc_experiment._samples[0].job = mock_job_1 - abc_experiment._samples[1].job = "example_job_id_2" - mock_job_2 = MagicMock() + mock_job_2 = MagicMock(spec=css.Job) mock_job_2.status.return_value = "Done" mock_job_2.job_id.return_value = "example_job_id_2" mock_job_2.counts.return_value = {"00": 5, "11": 10} - - abc_experiment._service = MagicMock() - abc_experiment._service.get_job.side_effect = [mock_job_1, mock_job_2] + abc_experiment._samples[1].job = mock_job_2 statuses = abc_experiment.retrieve_ss_jobs() - # Check get job calls - abc_experiment._service.get_job.assert_has_calls( - [call("example_job_id_1"), call("example_job_id_2")] - ) - # Check counts call mock_job_2.counts.assert_called_once_with(0) From f58dcd00209d12e249cdd97969868aeadc1ad855 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Wed, 31 Jul 2024 13:11:07 +0100 Subject: [PATCH 14/32] minor fix to tests and docs --- .../supermarq/qcvv/base_experiment.py | 15 ++++++++++++++- .../supermarq/qcvv/base_experiment_test.py | 3 ++- 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index 5feb5b10e..4dc7e5260 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -404,6 +404,12 @@ def build_circuits( def process_probabilities(self, samples: Sequence[Sample]) -> pd.DataFrame: """Processes the probabilities generated by sampling the circuits into a data frame needed for analyzing the results. + + Args: + samples: The list of samples to process the results from. + + Returns: + A data frame of the full results needed to analyse the experiment. """ @abstractmethod @@ -412,7 +418,14 @@ def plot_results(self) -> None: @abstractmethod def analyse_results(self, plot_results: bool = True) -> NamedTuple: - """Perform the experiment analysis and store the results in the `results` attribute""" + """Perform the experiment analysis and store the results in the `results` attribute + + Args: + plot_results: Whether to generate plots of the results. Defaults to False. + + Returns: + A named tuple of the final results from the experiment. + """ def _state_probs_to_dict( self, probs: np.typing.NDArray[np.float64], prefix: str = "", suffix: str = "" diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index 626c9046c..bc4688a7f 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -12,6 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # pylint: disable=missing-function-docstring +# pylint: disable=missing-return-doc # mypy: disable-error-code=method-assign from __future__ import annotations @@ -358,7 +359,7 @@ def test_clean_circuit( abc_experiment._clean_circuits() for sample in sample_circuits: - assert sample.circuit[-1] == cirq.Moment(cirq.measure(*sample.circuit.all_qubits())) + assert sample.circuit[-1] == cirq.Moment(cirq.measure(*sorted(sample.circuit.all_qubits()))) def test_process_device_counts(abc_experiment: BenchmarkingExperiment) -> None: From 3cde95e4b874ee9dbc8c0a0e38bed2f227c29803 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Wed, 31 Jul 2024 13:25:11 +0100 Subject: [PATCH 15/32] Reduce circuit count in example --- .../examples/qcvv/qcvv_css.ipynb | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index 48fe4dc85..d26596ea9 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -127,13 +127,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6a06de85b33b4d7a9115e384ab144d91", + "model_id": "abce0f2041494f5abdc36eefbd2ea8e7", "version_major": 2, "version_minor": 0 }, @@ -147,7 +147,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2c32cfbbc36d4ae98ec0638c9369a2f5", + "model_id": "bd3ef083994c4ede839552b657832461", "version_major": 2, "version_minor": 0 }, @@ -168,19 +168,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "NaiveExperimentResult(gate_fidelity=0.9863903425787091, gate_error=0.013609657421290944)\n" + "NaiveExperimentResult(gate_fidelity=0.9866048878241674, gate_error=0.013395112175832558)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -204,14 +204,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.010207243065968208\n" + "0.010046334131874418\n" ] } ], @@ -239,18 +239,18 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "13e532f86c9f46e692dfa638c593ea5c", + "model_id": "1a553530c55e4274bbab4220b942a356", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Building circuits.: 0%| | 0/30 [00:00 Date: Thu, 1 Aug 2024 11:35:20 +0100 Subject: [PATCH 16/32] Further fixes from code review --- .../examples/qcvv/qcvv_css.ipynb | 54 ++++++++------ .../supermarq/qcvv/base_experiment.py | 72 +++++++++++++++---- .../supermarq/qcvv/base_experiment_test.py | 62 +++++++++++++--- 3 files changed, 141 insertions(+), 47 deletions(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index d26596ea9..cea83e88c 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -40,13 +40,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample\n", + "from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample, QCVVResults\n", + "from dataclasses import dataclass\n", "from collections.abc import Sequence\n", - "from typing import Iterable, NamedTuple\n", + "from typing import Iterable\n", "from tqdm.contrib.itertools import product\n", "import pandas as pd\n", "\n", @@ -58,7 +59,8 @@ "import matplotlib.pyplot as plt\n", "\n", "\n", - "class NaiveExperimentResult(NamedTuple):\n", + "@dataclass(kw_only=True, frozen=True)\n", + "class NaiveExperimentResult(QCVVResults):\n", " gate_fidelity: float\n", " gate_error: float\n", "\n", @@ -74,7 +76,9 @@ " samples = []\n", " for _, depth in product(range(num_circuits), layers, desc=\"Building circuits.\"):\n", " circuit = cirq.Circuit([cirq.Z(*self.qubits) for _ in range(depth)])\n", + " circuit += cirq.measure(*self.qubits)\n", " samples.append(Sample(circuit=circuit, data={\"depth\": depth}))\n", + "\n", " return samples\n", "\n", " def process_probabilities(self, samples) -> None:\n", @@ -84,7 +88,7 @@ " records.append({**sample.data, **sample.probabilities})\n", " return pd.DataFrame(records)\n", "\n", - " def analyse_results(self, plot_results: bool = True) -> NamedTuple:\n", + " def analyse_results(self, plot_results: bool = True) -> NaiveExperiment:\n", " \"\"\"To analyse the results to fit a simple exponential decay. This can be done easily\n", " by fitting a linear model to the logarithm of the equation above.\n", " \"\"\"\n", @@ -93,7 +97,13 @@ "\n", " fidelity = np.exp(model.slope)\n", "\n", - " self._results = NaiveExperimentResult(gate_fidelity=fidelity, gate_error=1 - fidelity)\n", + " self._results = NaiveExperimentResult(\n", + " experiment_name=\"Naive Experiment\",\n", + " target=\"& \".join(self.sample_targets),\n", + " total_circuits=len(self.samples),\n", + " gate_fidelity=fidelity,\n", + " gate_error=1 - fidelity,\n", + " )\n", "\n", " if plot_results:\n", " self.plot_results()\n", @@ -127,13 +137,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "abce0f2041494f5abdc36eefbd2ea8e7", + "model_id": "e01fac6140ed49a8b30f28534fa7c7ba", "version_major": 2, "version_minor": 0 }, @@ -147,7 +157,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bd3ef083994c4ede839552b657832461", + "model_id": "9b85c0577e9a489da0533306a27da92b", "version_major": 2, "version_minor": 0 }, @@ -168,19 +178,19 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "NaiveExperimentResult(gate_fidelity=0.9866048878241674, gate_error=0.013395112175832558)\n" + "NaiveExperimentResult(experiment_name='Naive Experiment', target='Local simulator', total_circuits=30, gate_fidelity=0.9864470273790091, gate_error=0.013552972620990866)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -204,14 +214,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.010046334131874418\n" + "0.01016472946574315\n" ] } ], @@ -239,13 +249,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1a553530c55e4274bbab4220b942a356", + "model_id": "136dcfd38a1c461b88d97faaabf5b250", "version_major": 2, "version_minor": 0 }, @@ -259,12 +269,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b360975111184c8aaf910aaccbfb9a7f", + "model_id": "854fec47639b4128a064b7660ea9d2c8", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/15 [00:00 str: + """Returns: + The name of the target that the sample was submitted to + """ + if self.job is not None: + # If there is a job then get the target + return self.job.target() + + if hasattr(self, "probabilities"): + # If no job, but probabilities have been calculated, infer that a local + # simulator was used. + return "Local simulator" + + # Otherwise the experiment hasn't yet been run so there is no target. + return "No target" + + +@dataclass(kw_only=True, frozen=True) +class QCVVResults: + """A dataclass for storing the results of the experiment. Requires subclassing for + each new experiment type""" + + experiment_name: str + """The name of the experiment.""" + target: str + """The target device that was used.""" + total_circuits: int + """The total number of circuits used in the experiment.""" + class BenchmarkingExperiment(ABC): """Base class for gate benchmarking experiments. @@ -78,7 +108,7 @@ class BenchmarkingExperiment(ABC): results = experiment.analyse_results(<>) #. The final results of the experiment will be stored in the :code:`results` attribute as a - :class:`~typing.NamedTuple` of values, while all the data from the experiment will be + :class:`QCVVResults` of values, while all the data from the experiment will be stored in the :code:`raw_data` attribute as a :class:`~pandas.DataFrame`. Some experiments may include additional data attributes for data generated during the analysis. @@ -102,11 +132,14 @@ class BenchmarkingExperiment(ABC): into a :class:`pandas.DataFrame`. #. :meth:`analyse_results`: Analyse the data in the :attr:`raw_data` dataframe and return a - :class:`~typing.NamedTuple`-like object containing the results of the experiment. + :class:`QCVVResults` object containing the results of the experiment. #. :meth:`plot_results`: Produce any relevant plots that are useful for understanding the results of the experiment. + Additionally the :class:`QCVVResults` dataclass needs subclassing to hold the specific results + of the new experiment. + """ def __init__( @@ -117,6 +150,7 @@ def __init__( """Args: num_qubits: The number of qubits used during the experiment. Most subclasses will determine this from their other inputs. + kwargs: Additional kwargs passed to the Superstaq service object. """ self.qubits = cirq.LineQubit.range(num_qubits) """The qubits used in the experiment.""" @@ -124,16 +158,17 @@ def __init__( self._raw_data: pd.DataFrame | None = None "The data generated during the experiment" - self._results: NamedTuple | None = None + self._results: QCVVResults | None = None """The attribute to store the results in.""" self._samples: Sequence[Sample] | None = None """The attribute to store the experimental samples in.""" self._service: css.service.Service = css.service.Service(**kwargs) + """The superstaq service for submitting jobs.""" @property - def results(self) -> NamedTuple: + def results(self) -> QCVVResults: """The results from the most recently run experiment. Raises: @@ -175,15 +210,22 @@ def num_qubits(self) -> int: """ return len(self.qubits) - def _clean_circuits(self) -> None: - """Removes any terminal measurements that have been added to the circuit and replaces - them with a single measurement of the whole system in the computational basis + @property + def sample_targets(self) -> list[str]: + """Returns: + A list of the unique target that each sample was submitted to """ + return sorted(set(sample.target for sample in self.samples)) + + def _validate_circuits(self) -> None: + """Checks that all circuits contain a terminal measurement of all qubits.""" for sample in self.samples: - if sample.circuit.has_measurements(): - sample.circuit = cirq.drop_terminal_measurements(sample.circuit) - # Add measurement of qubit state in computational basis. - sample.circuit += cirq.measure(sorted(sample.circuit.all_qubits())) + if not sample.circuit.are_all_measurements_terminal(): + raise ValueError("QCVV experiment circuits can only contain terminal measurements") + if not sorted(sample.circuit[-1].qubits) == sorted(self.qubits): + raise ValueError( + "The terminal measurement in QCVV experiment circuits must measure all qubits." + ) def _prepare_experiment( self, num_circuits: int, cycle_depths: Iterable[int], overwrite: bool = False @@ -211,7 +253,7 @@ def _prepare_experiment( raise ValueError("The `cycle_depths` iterator can only include positive values.") self._samples = self.build_circuits(num_circuits, cycle_depths) - self._clean_circuits() + self._validate_circuits() def run_on_device( self, @@ -243,7 +285,7 @@ def run_on_device( """ self._prepare_experiment(num_circuits, cycle_depths, overwrite) - for sample in tqdm(self.samples): + for sample in tqdm(self.samples, desc="Submitting jobs"): if sample.job is not None: continue try: @@ -417,7 +459,7 @@ def plot_results(self) -> None: """Plot the results of the experiment""" @abstractmethod - def analyse_results(self, plot_results: bool = True) -> NamedTuple: + def analyse_results(self, plot_results: bool = True) -> QCVVResults: """Perform the experiment analysis and store the results in the `results` attribute Args: diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index bc4688a7f..efbba2889 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -18,7 +18,7 @@ from __future__ import annotations import os -from typing import NamedTuple +from dataclasses import dataclass from unittest.mock import MagicMock, call, patch import cirq @@ -28,7 +28,7 @@ import pytest from general_superstaq.superstaq_exceptions import SuperstaqServerException -from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample +from supermarq.qcvv.base_experiment import BenchmarkingExperiment, QCVVResults, Sample @pytest.fixture(scope="session", autouse=True) @@ -55,12 +55,25 @@ def sample_circuits() -> list[Sample]: ] -class ExampleResults(NamedTuple): +@dataclass(kw_only=True, frozen=True) +class ExampleResults(QCVVResults): """NamedTuple instance to use for testing""" example: float +def test_sample_target_property() -> None: + sample = Sample(circuit=MagicMock(), data={}) + assert sample.target == "No target" + + sample.probabilities = {"0": 0.25, "1": 0.75} + assert sample.target == "Local simulator" + + sample.job = MagicMock() + sample.job.target.return_value = "Example target" + assert sample.target == "Example target" + + def test_benchmarking_experiment_init(abc_experiment: BenchmarkingExperiment) -> None: assert abc_experiment.num_qubits == 2 assert abc_experiment._raw_data is None @@ -68,7 +81,9 @@ def test_benchmarking_experiment_init(abc_experiment: BenchmarkingExperiment) -> assert abc_experiment._samples is None abc_experiment._raw_data = pd.DataFrame([{"Example": 0.1}]) - abc_experiment._results = ExampleResults(example=5.0) + abc_experiment._results = ExampleResults( + experiment_name="Example", target="Some target", total_circuits=2, example=5.0 + ) pd.testing.assert_frame_equal(abc_experiment.raw_data, abc_experiment._raw_data) assert abc_experiment.results == abc_experiment._results @@ -108,12 +123,12 @@ def test_prepare_experiment_overwrite_error(abc_experiment: BenchmarkingExperime def test_prepare_experiment_overwrite(abc_experiment: BenchmarkingExperiment) -> None: abc_experiment._samples = [Sample(circuit=MagicMock(), data={})] abc_experiment.build_circuits = MagicMock() - abc_experiment._clean_circuits = MagicMock() + abc_experiment._validate_circuits = MagicMock() abc_experiment._prepare_experiment(100, [1, 50, 100], overwrite=True) abc_experiment.build_circuits.assert_called_once_with(100, [1, 50, 100]) - abc_experiment._clean_circuits.assert_called_once_with() + abc_experiment._validate_circuits.assert_called_once_with() def test_prepare_experiment_with_bad_layers(abc_experiment: BenchmarkingExperiment) -> None: @@ -352,14 +367,41 @@ def test_sample_statuses( mock_job.status.assert_called_once_with() -def test_clean_circuit( +def test_sample_targets( + abc_experiment: BenchmarkingExperiment, +) -> None: + abc_experiment._samples = [mock_sample_0 := MagicMock(), mock_sample_1 := MagicMock()] + mock_sample_0.target = "target_0" + mock_sample_1.target = "target_1" + assert abc_experiment.sample_targets == ["target_0", "target_1"] + + mock_sample_1.target = "target_0" + assert abc_experiment.sample_targets == ["target_0"] + + +def test_validate_circuits( abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits - abc_experiment._clean_circuits() + # Should't get any errors with the base circuits + abc_experiment._validate_circuits() + + # Add a gate so not all measurements are terminal + abc_experiment._samples[0].circuit += cirq.X(abc_experiment.qubits[0]) + with pytest.raises( + ValueError, match="QCVV experiment circuits can only contain terminal measurements" + ): + abc_experiment._validate_circuits() - for sample in sample_circuits: - assert sample.circuit[-1] == cirq.Moment(cirq.measure(*sorted(sample.circuit.all_qubits()))) + # Remove measurements + abc_experiment._samples[0].circuit = abc_experiment._samples[0].circuit[:-2] + cirq.measure( + abc_experiment.qubits[0] + ) + with pytest.raises( + ValueError, + match="The terminal measurement in QCVV experiment circuits must measure all qubits.", + ): + abc_experiment._validate_circuits() def test_process_device_counts(abc_experiment: BenchmarkingExperiment) -> None: From 16cf1253478b52ba4f594d0fd73ab16b55aafe24 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Thu, 1 Aug 2024 11:49:11 +0100 Subject: [PATCH 17/32] Remove kw_only data classes as it doesn't work with python 3.8 --- supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb | 2 +- supermarq-benchmarks/supermarq/qcvv/base_experiment.py | 2 +- supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index cea83e88c..80862f9dc 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -59,7 +59,7 @@ "import matplotlib.pyplot as plt\n", "\n", "\n", - "@dataclass(kw_only=True, frozen=True)\n", + "@dataclass(frozen=True)\n", "class NaiveExperimentResult(QCVVResults):\n", " gate_fidelity: float\n", " gate_error: float\n", diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index cc768554c..2fcf76f74 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -63,7 +63,7 @@ def target(self) -> str: return "No target" -@dataclass(kw_only=True, frozen=True) +@dataclass(frozen=True) class QCVVResults: """A dataclass for storing the results of the experiment. Requires subclassing for each new experiment type""" diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index efbba2889..4bfcfdc55 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -55,7 +55,7 @@ def sample_circuits() -> list[Sample]: ] -@dataclass(kw_only=True, frozen=True) +@dataclass(frozen=True) class ExampleResults(QCVVResults): """NamedTuple instance to use for testing""" From 2a0092cb2ed1146e738e3bd4dddfbf55cad74fb0 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 2 Aug 2024 10:18:54 +0100 Subject: [PATCH 18/32] Fix: add functionality for multiple subjobs --- cirq-superstaq/cirq_superstaq/job.py | 14 +++ cirq-superstaq/cirq_superstaq/job_test.py | 27 ++++++ .../examples/qcvv/qcvv_css.ipynb | 34 ++----- .../supermarq/qcvv/base_experiment.py | 37 +++---- .../supermarq/qcvv/base_experiment_test.py | 96 ++++--------------- 5 files changed, 82 insertions(+), 126 deletions(-) diff --git a/cirq-superstaq/cirq_superstaq/job.py b/cirq-superstaq/cirq_superstaq/job.py index fd4bf30ce..f0c26c96e 100644 --- a/cirq-superstaq/cirq_superstaq/job.py +++ b/cirq-superstaq/cirq_superstaq/job.py @@ -460,6 +460,20 @@ def __repr__(self) -> str: def _value_equality_values_(self) -> tuple[str, dict[str, Any]]: return self._job_id, self._job + def __getitem__(self, idx: int) -> css.Job: + """Args: + idx: The index of the sub-job to return. Each sub-job corresponds to the a single + circuit. + + Returns: + A sub-job at the given index. + """ + job_id = self._job_id.split(",")[idx] + sub_job = css.Job(self._client, job_id) + if job_id in self._job: + sub_job._job[job_id] = self._job[job_id] + return sub_job + def _get_marginal_counts(counts: dict[str, int], indices: Sequence[int]) -> dict[str, int]: """Compute a marginal distribution, accumulating total counts on specific bits (by index). diff --git a/cirq-superstaq/cirq_superstaq/job_test.py b/cirq-superstaq/cirq_superstaq/job_test.py index ad6cf1e3d..813df0529 100644 --- a/cirq-superstaq/cirq_superstaq/job_test.py +++ b/cirq-superstaq/cirq_superstaq/job_test.py @@ -53,6 +53,27 @@ def new_job() -> css.Job: return css.Job(client, "new_job_id") +@pytest.fixture +def multi_circuit_job() -> css.Job: + """Fixture for a job with multiple circuits submitted + + Returns: + A job with multiple subjobs + """ + client = gss.superstaq_client._SuperstaqClient( + client_name="cirq-superstaq", + remote_host="http://example.com", + api_key="to_my_heart", + ) + job = css.Job(client, "job_id1,job_id2,job_id3") + job._job = { + "job_id1": css.Job(client, "job_id1"), + "job_id2": css.Job(client, "job_id2"), + "job_id3": css.Job(client, "job_id3"), + } + return job + + def mocked_get_job_requests(*job_dicts: dict[str, Any]) -> mock._patch[mock.Mock]: """Mocks the server's response to `get_job` requests using the given sequence of job_dicts. Return type is wrapped in a string because "'type' object is not subscriptable" @@ -455,6 +476,12 @@ def test_job_results_poll_failure(mock_sleep: mock.MagicMock, job: css.job.Job) assert mock_sleep.call_count == 5 +def test_job_getitem(multi_circuit_job: css.job.Job) -> None: + job_1 = multi_circuit_job[0] + assert isinstance(job_1, css.Job) + assert job_1.job_id() == "job_id1" + + def test_get_marginal_counts() -> None: counts_dict = {"10": 50, "11": 50} indices = [0] diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index 80862f9dc..5b302d37e 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -143,7 +143,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e01fac6140ed49a8b30f28534fa7c7ba", + "model_id": "01239511c7da4cdba676345288a220b5", "version_major": 2, "version_minor": 0 }, @@ -157,7 +157,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9b85c0577e9a489da0533306a27da92b", + "model_id": "55291d63fe3343e0b345fddcd7c341c4", "version_major": 2, "version_minor": 0 }, @@ -185,12 +185,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "NaiveExperimentResult(experiment_name='Naive Experiment', target='Local simulator', total_circuits=30, gate_fidelity=0.9864470273790091, gate_error=0.013552972620990866)\n" + "NaiveExperimentResult(experiment_name='Naive Experiment', target='Local simulator', total_circuits=30, gate_fidelity=0.9862489774018681, gate_error=0.013751022598131879)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -221,7 +221,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.01016472946574315\n" + "0.01031326694859891\n" ] } ], @@ -249,13 +249,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "136dcfd38a1c461b88d97faaabf5b250", + "model_id": "0adc5543d95b43eda6eed66876983e8e", "version_major": 2, "version_minor": 0 }, @@ -265,37 +265,23 @@ }, "metadata": {}, "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "854fec47639b4128a064b7660ea9d2c8", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Submitting jobs: 0%| | 0/15 [00:00 None: + ) -> css.Job: """Submit the circuit samples to the desired target device and store the resulting probabilities. @@ -282,28 +280,23 @@ def run_on_device( target_options: Optional configuration dictionary passed when submitting the job. overwrite: Whether to force an experiment run even if there is existing data that would be over written in the process. Defaults to False. + + Return: + The superstaq job containing all the circuits submitted as part of the experiment. """ self._prepare_experiment(num_circuits, cycle_depths, overwrite) - for sample in tqdm(self.samples, desc="Submitting jobs"): - if sample.job is not None: - continue - try: - sample.job = self._service.create_job( - sample.circuit, - target=target, - method=method, - repetitions=shots, - **target_options, - ) - except SuperstaqServerException as error: - warnings.warn( - "The following error ocurred when submitting the jobs to the server and not\n" - "all jobs have been submitted. If this is a timeout or limit based error\n" - "consider running `submit_ss_jobs(args)` again to continue submitting\n" - "the outstanding jobs.\n" - f"{error.message}" - ) + experiment_job = self._service.create_job( + [sample.circuit for sample in self.samples], + target=target, + method=method, + repetitions=shots, + **target_options, + ) + for k, sample in enumerate(self.samples): + sample.job = experiment_job[k] + + return experiment_job def sample_statuses(self) -> list[str | None]: """Returns: diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index 4bfcfdc55..8022e5b95 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -26,7 +26,6 @@ import numpy as np import pandas as pd import pytest -from general_superstaq.superstaq_exceptions import SuperstaqServerException from supermarq.qcvv.base_experiment import BenchmarkingExperiment, QCVVResults, Sample @@ -202,33 +201,21 @@ def test_run_on_device( abc_experiment._prepare_experiment = MagicMock() abc_experiment._samples = sample_circuits abc_experiment._service = (mock_service := MagicMock()) - mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] - mock_service().target_info.return_value = {} - abc_experiment.run_on_device( + job = abc_experiment.run_on_device( 10, [5, 10, 20], target="example_target", shots=100, overwrite=False, **{"some": "options"} ) - mock_service.create_job.assert_has_calls( - [ - call( - sample_circuits[0].circuit, - target="example_target", - method=None, - repetitions=100, - some="options", - ), - call( - sample_circuits[1].circuit, - target="example_target", - method=None, - repetitions=100, - some="options", - ), - ], - any_order=True, + mock_service.create_job.assert_called_once_with( + [sample_circuits[0].circuit, sample_circuits[1].circuit], + target="example_target", + method=None, + repetitions=100, + some="options", ) + assert job == mock_service.create_job.return_value + abc_experiment._prepare_experiment.assert_called_once_with(10, [5, 10, 20], False) @@ -238,69 +225,18 @@ def test_run_on_device_dry_run( abc_experiment._prepare_experiment = MagicMock() abc_experiment._samples = sample_circuits abc_experiment._service = (mock_service := MagicMock()) - mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] - mock_service().target_info.return_value = {} - abc_experiment.run_on_device( + job = abc_experiment.run_on_device( 10, [5, 10, 20], target="example_target", shots=100, method="dry-run" ) - mock_service.create_job.assert_has_calls( - [ - call( - sample_circuits[0].circuit, - target="example_target", - method="dry-run", - repetitions=100, - ), - call( - sample_circuits[1].circuit, - target="example_target", - method="dry-run", - repetitions=100, - ), - ], - any_order=True, + mock_service.create_job.assert_called_once_with( + [sample_circuits[0].circuit, sample_circuits[1].circuit], + target="example_target", + method="dry-run", + repetitions=100, ) - - -def test_run_on_device_job_already_has_id( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] -) -> None: - abc_experiment._prepare_experiment = MagicMock() - abc_experiment._samples = sample_circuits - sample_circuits[0].job = MagicMock() - abc_experiment._service = (mock_service := MagicMock()) - mock_service().create_job.side_effect = [MagicMock(job_id="job_1"), MagicMock(job_id="job_2")] - - mock_service().target_info.return_value = {} - abc_experiment.run_on_device( - 10, [5, 10, 20], target="example_target", shots=100, method="example_method" - ) - - mock_service.create_job.assert_has_calls( - [ - call( - sample_circuits[1].circuit, - target="example_target", - method="example_method", - repetitions=100, - ), - ], - any_order=True, - ) - - -def test_run_on_device_with_exception( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] -) -> None: - abc_experiment._samples = sample_circuits - abc_experiment._service = (mock_service := MagicMock()) - abc_experiment._prepare_experiment = MagicMock() - - mock_service.create_job.side_effect = SuperstaqServerException("example_exception") - with pytest.warns(UserWarning): - abc_experiment.run_on_device(10, [5, 10, 20], target="example_target", shots=100) + assert job == mock_service.create_job.return_value def test_state_probs_to_dict(abc_experiment: BenchmarkingExperiment) -> None: From c3e40d465095ceddfd1e613d73697aa938f60187 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Tue, 16 Jul 2024 09:45:55 +0100 Subject: [PATCH 19/32] Feature: Implement IRB routine --- cirq-superstaq/cirq_superstaq/qcvv/irb.py | 278 ++++++++++++++++++ .../cirq_superstaq/qcvv/irb_test.py | 261 ++++++++++++++++ supermarq-benchmarks/examples/qcvv/qcvv.rst | 11 + .../examples/qcvv/qcvv_irb_css.ipynb | 16 + 4 files changed, 566 insertions(+) create mode 100644 cirq-superstaq/cirq_superstaq/qcvv/irb.py create mode 100644 cirq-superstaq/cirq_superstaq/qcvv/irb_test.py create mode 100644 supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb diff --git a/cirq-superstaq/cirq_superstaq/qcvv/irb.py b/cirq-superstaq/cirq_superstaq/qcvv/irb.py new file mode 100644 index 000000000..389471b24 --- /dev/null +++ b/cirq-superstaq/cirq_superstaq/qcvv/irb.py @@ -0,0 +1,278 @@ +# Copyright 2021 The Cirq Developers +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Tooling for interleaved randomised benchmarking +""" + +from __future__ import annotations + +import random +from collections.abc import Iterable, Sequence +from typing import NamedTuple, cast + +import cirq +import numpy as np +import pandas as pd +import seaborn as sns +from scipy.stats import linregress +from tqdm.contrib.itertools import product + +from cirq_superstaq.qcvv.base_experiment import BenchmarkingExperiment, Sample + + +class IRBResults(NamedTuple): + """Data structure for the IRB experiment results.""" + + rb_layer_fidelity: float + """Layer fidelity estimate without the interleaving gate.""" + rb_layer_fidelity_std: float + """Standard deviation of the layer fidelity estimate without the interleaving gate.""" + irb_layer_fidelity: float + """Layer fidelity estimate with the interleaving gate.""" + irb_layer_fidelity_std: float + """Standard deviation of the layer fidelity estimate with the interleaving gate.""" + interleaved_gate_error: float + """Estimate of the interleaving gate error.""" + interleaved_gate_error_std: float + """Standard deviation of the estimate for the interleaving gate error.""" + + +class IRB(BenchmarkingExperiment): + r"""Interleaved random benchmarking (IRB) experiment. + + IRB estimates the gate error of specified Clifford gate, :math:`\mathcal{C}^*`. + This is achieved by first choosing a random sequence, :math:`\{\mathcal{C_i}\}_m` + of :math:`m` Clifford gates and then using this to generate two circuits. The first + is generated by appending to this sequence the single gate that corresponds to the + inverse of the original sequence. The second circuit it obtained by inserting the + interleaving gate, :math:`\mathcal{C}^*` after each gate in the sequence and then + again appending the corresponding inverse element of the new circuit. Thus both + circuits correspond to the identity operation. + + We run both circuits on the specified target and calculate the probability of measuring + the resulting state in the ground state, :math:`p(0...0)`. This gives the circuit fidelity + + .. math:: + + f(m) = 2p(0...0) - 1 + + We can then fit and exponential decay :math:`\log(f) \sim m` to this circuit fidelity + for each circuit, with decay rates :math:`\alpha` and :math:`\tilde{\alpha}` for the circuit + without and with interleaving respectively. Finally the gate error of the + specified gate, :math:`\mathcal{C}^*` is estimated as + + .. math:: + + e_{\mathcal{C}^*} = 1 - \frac{\tilde{\alpha}}{\alpha} + + """ + + def __init__( + self, + interleaved_gate: cirq.ops.SingleQubitCliffordGate = cirq.ops.SingleQubitCliffordGate.Z, + num_qubits: int = 1, + ): + """Args: + interleaved_gate: The Clifford gate to measure the gate error of. + num_qubits: The number of qubits to experiment on + """ + if num_qubits != 1: + raise NotImplementedError( + "IRB experiment is currently only implemented for single qubit use" + ) + super().__init__(num_qubits=1) + + self.interleaved_gate = interleaved_gate + """The gate being interleaved""" + + @property + def results(self) -> IRBResults: + """The results from the most recently run experiment""" + return cast("IRBResults", super().results) + + @staticmethod + def _reduce_clifford_seq( + gate_seq: list[cirq.ops.SingleQubitCliffordGate], + ) -> cirq.ops.SingleQubitCliffordGate: + """Reduces a list of single qubit clifford gates to a single gate. + + Args: + gate_seq: The list of gates. + + Returns: + The single reduced gate + """ + cur = gate_seq[0] + for gate in gate_seq[1:]: + cur = cur.merged_with(gate) + return cur + + @classmethod + def _random_single_qubit_clifford(cls) -> cirq.ops.SingleQubitCliffordGate: + """Choose a random singe qubit clifford gate. + + Returns: + The random clifford gate. + """ + Id = cirq.ops.SingleQubitCliffordGate.I + H = cirq.ops.SingleQubitCliffordGate.H + S = cirq.ops.SingleQubitCliffordGate.Z_sqrt + X = cirq.ops.SingleQubitCliffordGate.X + Y = cirq.ops.SingleQubitCliffordGate.Y + Z = cirq.ops.SingleQubitCliffordGate.Z + + set_A = [ + Id, + S, + H, + cls._reduce_clifford_seq([H, S]), + cls._reduce_clifford_seq([S, H]), + cls._reduce_clifford_seq([H, S, H]), + ] + + set_B = [Id, X, Y, Z] + + return cls._reduce_clifford_seq([random.choice(set_A), random.choice(set_B)]) + + def _invert_clifford_circuit(self, circuit: cirq.Circuit) -> cirq.Circuit: + """Given a Clifford circuit find and append the corresponding inverse Clifford gate + + Args: + circuit: The Clifford circuit to invert. + + Returns: + A copy of the original Clifford circuit with the inverse element appended. + """ + clifford_gates = [op.gate for op in circuit.all_operations()] + inv_element = self._reduce_clifford_seq( + cirq.inverse(clifford_gates) # type: ignore[arg-type] + ) + clifford_gates.append(inv_element) + return cirq.Circuit(*[gate(*self.qubits) for gate in clifford_gates]) # type: ignore[misc] + + def build_circuits(self, num_circuits: int, layers: Iterable[int]) -> Sequence[Sample]: + """Build a list of randomised circuits required for the IRB experiment. + These circuits do not include the interleaving gate or the final inverse + gate, instead these are added in the :meth:`sample_circuit` function. + + Args: + num_circuits: Number of circuits to generate. + layers: TODO + + Returns: + TODO + """ + samples = [] + for _, depth in product(range(num_circuits), layers, desc="Building circuits"): + base_circuit = cirq.Circuit( + *[self._random_single_qubit_clifford()(*self.qubits) for _ in range(depth)] + ) + rb_circuit = self._invert_clifford_circuit(base_circuit) + irb_circuit = self._invert_clifford_circuit( + self._interleave_gate(base_circuit, self.interleaved_gate, include_final=True) + ) + samples += [ + Sample( + circuit=rb_circuit, + data={ + "num_cycles": depth, + "circuit_depth": len(rb_circuit), + "experiment": "RB", + }, + ), + Sample( + circuit=irb_circuit, + data={ + "num_cycles": depth, + "circuit_depth": len(irb_circuit), + "experiment": "IRB", + }, + ), + ] + + return samples + + def process_probabilities(self) -> None: + """Processes the probabilities generated by sampling the circuits into the data structures + needed for analyzing the results. + """ + super().process_probabilities() + + records = [] + for sample in self.samples: + records.append( + { + "clifford_depth": sample.data["num_cycles"], + "circuit_depth": sample.data["circuit_depth"], + "experiment": sample.data["experiment"], + **sample.probabilities, + } + ) + + self._raw_data = pd.DataFrame(records) + + def plot_results(self) -> None: + """Plot the exponential decay of the circuit fidelity with + cycle depth. + """ + plot = sns.lmplot( + data=self.raw_data, + x="clifford_depth", + y="log_fidelity", + hue="experiment", + ) + ax = plot.axes.item() + plot.tight_layout() + ax.set_xlabel(r"Cycle depth", fontsize=15) + ax.set_ylabel(r"Log Circuit fidelity", fontsize=15) + ax.set_title(r"Exponential decay of circuit fidelity", fontsize=15) + + def analyse_results(self, plot_results: bool = True) -> IRBResults: + """Analyse the experiment results and estimate the interleaved gate error.""" + + self.raw_data["fidelity"] = 2 * self.raw_data["0"] - 1 + self.raw_data["log_fidelity"] = np.log(self.raw_data["fidelity"]) + + rb_model = linregress( + self.raw_data.query("experiment == 'RB'")["clifford_depth"], + np.log(self.raw_data.query("experiment == 'RB'")["fidelity"]), + ) + irb_model = linregress( + self.raw_data.query("experiment == 'IRB'")["clifford_depth"], + np.log(self.raw_data.query("experiment == 'IRB'")["fidelity"]), + ) + + # Extract fit values. + rb_layer_fidelity = np.exp(rb_model.slope) + rb_layer_fidelity_std = rb_model.stderr * rb_layer_fidelity + irb_layer_fidelity = np.exp(irb_model.slope) + irb_layer_fidelity_std = irb_model.stderr * irb_layer_fidelity + + interleaved_gate_error = 1 - irb_layer_fidelity / rb_layer_fidelity + interleaved_gate_error_std = interleaved_gate_error * np.sqrt( + (rb_layer_fidelity_std / rb_layer_fidelity) ** 2 + + (irb_layer_fidelity_std / irb_layer_fidelity) ** 2 + ) + + self._results = IRBResults( + rb_layer_fidelity=rb_layer_fidelity, + rb_layer_fidelity_std=rb_layer_fidelity_std, + irb_layer_fidelity=irb_layer_fidelity, + irb_layer_fidelity_std=irb_layer_fidelity_std, + interleaved_gate_error=interleaved_gate_error, + interleaved_gate_error_std=interleaved_gate_error_std, + ) + + if plot_results: + self.plot_results() + + return self.results diff --git a/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py b/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py new file mode 100644 index 000000000..42706f7d0 --- /dev/null +++ b/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py @@ -0,0 +1,261 @@ +# Copyright 2021 The Cirq Developers +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# pylint: disable=missing-function-docstring +# mypy: disable-error-code=method-assign +from __future__ import annotations + +import os +from unittest.mock import MagicMock + +import cirq +import pandas as pd +import pytest + +from cirq_superstaq.qcvv.base_experiment import Sample +from cirq_superstaq.qcvv.irb import IRB + + +@pytest.fixture(scope="session", autouse=True) +def patch_tqdm() -> None: + os.environ["TQDM_DISABLE"] = "1" + + +def test_irb_init() -> None: + experiment = IRB() + assert experiment.num_qubits == 1 + assert experiment.interleaved_gate == cirq.ops.SingleQubitCliffordGate.Z + + experiment = IRB(interleaved_gate=cirq.ops.SingleQubitCliffordGate.X) + assert experiment.num_qubits == 1 + assert experiment.interleaved_gate == cirq.ops.SingleQubitCliffordGate.X + + with pytest.raises(NotImplementedError): + IRB(num_qubits=2) + + +@pytest.fixture +def irb_experiment() -> IRB: + return IRB() + + +def test_reduce_clifford_sequence() -> None: + sequence = [ + cirq.ops.SingleQubitCliffordGate.X, + cirq.ops.SingleQubitCliffordGate.X, + cirq.ops.SingleQubitCliffordGate.Z, + ] + + combined_gate = IRB._reduce_clifford_seq(sequence) + assert combined_gate == cirq.ops.SingleQubitCliffordGate.Z + + +def test_random_single_qubit_clifford() -> None: + gate = IRB._random_single_qubit_clifford() + assert isinstance(gate, cirq.ops.SingleQubitCliffordGate) + + +def test_invert_clifford_circuit(irb_experiment: IRB) -> None: + circuit = cirq.Circuit( + [ + cirq.ops.SingleQubitCliffordGate.X(irb_experiment.qubits[0]), + cirq.ops.SingleQubitCliffordGate.Y(irb_experiment.qubits[0]), + ] + ) + inverse = irb_experiment._invert_clifford_circuit(circuit) + expected_inverse = circuit + cirq.ops.SingleQubitCliffordGate.Z(irb_experiment.qubits[0]) + + cirq.testing.assert_same_circuits(inverse, expected_inverse) + + +def test_irb_process_probabilities(irb_experiment: IRB) -> None: + + samples = [ + Sample( + circuit=cirq.Circuit(), + data={ + "num_cycles": 20, + "circuit_depth": 23, + "experiment": "example", + }, + ) + ] + samples[0].probabilities = {"00": 0.1, "01": 0.2, "10": 0.3, "11": 0.4} + irb_experiment._samples = samples + + irb_experiment.process_probabilities() + + expected_data = pd.DataFrame( + [ + { + "clifford_depth": 20, + "circuit_depth": 23, + "experiment": "example", + "00": 0.1, + "01": 0.2, + "10": 0.3, + "11": 0.4, + } + ] + ) + + pd.testing.assert_frame_equal(expected_data, irb_experiment.raw_data) + + +def test_irb_build_circuit(irb_experiment: IRB) -> None: + irb_experiment._random_single_qubit_clifford = (mock_random_clifford := MagicMock()) + mock_random_clifford.side_effect = [ + cirq.ops.SingleQubitCliffordGate.Z, + cirq.ops.SingleQubitCliffordGate.Z, + cirq.ops.SingleQubitCliffordGate.Z, + cirq.ops.SingleQubitCliffordGate.X, + cirq.ops.SingleQubitCliffordGate.X, + cirq.ops.SingleQubitCliffordGate.X, + ] + + circuits = irb_experiment.build_circuits(2, [3]) + expected_circuits = [ + Sample( + circuit=cirq.Circuit( + [ + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + ] + ), + data={ + "num_cycles": 3, + "circuit_depth": 4, + "experiment": "RB", + }, + ), + Sample( + circuit=cirq.Circuit( + [ + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.I(*irb_experiment.qubits), + ] + ), + data={ + "num_cycles": 3, + "circuit_depth": 7, + "experiment": "IRB", + }, + ), + Sample( + circuit=cirq.Circuit( + [ + cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), + ] + ), + data={ + "num_cycles": 3, + "circuit_depth": 4, + "experiment": "RB", + }, + ), + Sample( + circuit=cirq.Circuit( + [ + cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.ops.SingleQubitCliffordGate.Y(*irb_experiment.qubits), + ] + ), + data={ + "num_cycles": 3, + "circuit_depth": 7, + "experiment": "IRB", + }, + ), + ] + + assert len(circuits) == 4 + + cirq.testing.assert_same_circuits(circuits[0].circuit, expected_circuits[0].circuit) + assert circuits[0].data == expected_circuits[0].data + cirq.testing.assert_same_circuits(circuits[1].circuit, expected_circuits[1].circuit) + assert circuits[1].data == expected_circuits[1].data + cirq.testing.assert_same_circuits(circuits[2].circuit, expected_circuits[2].circuit) + assert circuits[2].data == expected_circuits[2].data + cirq.testing.assert_same_circuits(circuits[3].circuit, expected_circuits[3].circuit) + assert circuits[3].data == expected_circuits[3].data + + +def test_analyse_results(irb_experiment: IRB) -> None: + irb_experiment._raw_data = pd.DataFrame( + [ + { + "clifford_depth": 1, + "circuit_depth": 2, + "experiment": "RB", + "0": 0.5 * 0.95**1 + 0.5, + "1": 0.5 - 0.5 * 0.95**1, + }, + { + "clifford_depth": 1, + "circuit_depth": 3, + "experiment": "IRB", + "0": 0.5 * 0.8**1 + 0.5, + "1": 0.5 - 0.5 * 0.8**1, + }, + { + "clifford_depth": 5, + "circuit_depth": 6, + "experiment": "RB", + "0": 0.5 * 0.95**5 + 0.5, + "1": 0.5 - 0.5 * 0.95**5, + }, + { + "clifford_depth": 5, + "circuit_depth": 11, + "experiment": "IRB", + "0": 0.5 * 0.8**5 + 0.5, + "1": 0.5 - 0.5 * 0.8**5, + }, + { + "clifford_depth": 10, + "circuit_depth": 11, + "experiment": "RB", + "0": 0.5 * 0.95**10 + 0.5, + "1": 0.5 - 0.5 * 0.95**10, + }, + { + "clifford_depth": 10, + "circuit_depth": 21, + "experiment": "IRB", + "0": 0.5 * 0.8**10 + 0.5, + "1": 0.5 - 0.5 * 0.8**10, + }, + ] + ) + irb_experiment.analyse_results() + + assert irb_experiment.results.rb_layer_fidelity == pytest.approx(0.95) + assert irb_experiment.results.irb_layer_fidelity == pytest.approx(0.8) + assert irb_experiment.results.interleaved_gate_error == pytest.approx(1 - 0.8 / 0.95) + + # Test that plotting results doesn't introduce any errors. + irb_experiment.plot_results() diff --git a/supermarq-benchmarks/examples/qcvv/qcvv.rst b/supermarq-benchmarks/examples/qcvv/qcvv.rst index 9648b27c1..b0017fa0e 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv.rst +++ b/supermarq-benchmarks/examples/qcvv/qcvv.rst @@ -10,3 +10,14 @@ For a demonstration of how to implement a new experiment take a look at the foll :maxdepth: 1 qcvv_css + +Alternatively for pre-built experiments that can be used out of the box see + +.. toctree:: + :maxdepth: 1 + + qcvv_irb_css + +.. note:: + + At present the QCVV library is only available in :code:`cirq-superstaq`. \ No newline at end of file diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb new file mode 100644 index 000000000..d3e2deab1 --- /dev/null +++ b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb @@ -0,0 +1,16 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From a66304f6b3b9f86ec25382972527e166266bde9b Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Tue, 16 Jul 2024 12:52:17 +0100 Subject: [PATCH 20/32] feature: start building notebook --- .../examples/qcvv/qcvv_irb_css.ipynb | 111 +++++++++++++++++- 1 file changed, 109 insertions(+), 2 deletions(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb index d3e2deab1..6be949d5b 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb @@ -3,12 +3,119 @@ { "cell_type": "markdown", "metadata": {}, - "source": [] + "source": [ + "# Interleaved Randomized Benchmarking (IRB)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The interleaved randomized benchmarking routine allows us to estimate the gate fidelity of single\n", + "qubit Clifford gates. To demonstrate this routine, consider device noise modelled by an amplitude \n", + "damping channel with decay probability $\\gamma=0.01$" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import cirq\n", + "noise = cirq.AmplitudeDampingChannel(gamma=0.01)\n", + "target = cirq.DensityMatrixSimulator(noise=noise)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ecec67c03e9f40f4b04d269bba12d183", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Building circuits: 0%| | 0/600 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "experiment.analyse_results()" + ] } ], "metadata": { + "kernelspec": { + "display_name": "client_superstaq", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" } }, "nbformat": 4, From 08f2aac35aadd2457f498e7a65b7061807424468 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Tue, 16 Jul 2024 13:16:24 +0100 Subject: [PATCH 21/32] Finish adding example notebook --- cirq-superstaq/cirq_superstaq/qcvv/irb.py | 10 ++-- .../cirq_superstaq/qcvv/irb_test.py | 4 +- .../examples/qcvv/qcvv_irb_css.ipynb | 56 ++++++++++++++++--- 3 files changed, 55 insertions(+), 15 deletions(-) diff --git a/cirq-superstaq/cirq_superstaq/qcvv/irb.py b/cirq-superstaq/cirq_superstaq/qcvv/irb.py index 389471b24..927dd18a9 100644 --- a/cirq-superstaq/cirq_superstaq/qcvv/irb.py +++ b/cirq-superstaq/cirq_superstaq/qcvv/irb.py @@ -40,9 +40,9 @@ class IRBResults(NamedTuple): """Layer fidelity estimate with the interleaving gate.""" irb_layer_fidelity_std: float """Standard deviation of the layer fidelity estimate with the interleaving gate.""" - interleaved_gate_error: float + average_interleaved_gate_error: float """Estimate of the interleaving gate error.""" - interleaved_gate_error_std: float + average_interleaved_gate_error_std: float """Standard deviation of the estimate for the interleaving gate error.""" @@ -257,7 +257,7 @@ def analyse_results(self, plot_results: bool = True) -> IRBResults: irb_layer_fidelity = np.exp(irb_model.slope) irb_layer_fidelity_std = irb_model.stderr * irb_layer_fidelity - interleaved_gate_error = 1 - irb_layer_fidelity / rb_layer_fidelity + interleaved_gate_error = (1 - irb_layer_fidelity / rb_layer_fidelity) / 2 interleaved_gate_error_std = interleaved_gate_error * np.sqrt( (rb_layer_fidelity_std / rb_layer_fidelity) ** 2 + (irb_layer_fidelity_std / irb_layer_fidelity) ** 2 @@ -268,8 +268,8 @@ def analyse_results(self, plot_results: bool = True) -> IRBResults: rb_layer_fidelity_std=rb_layer_fidelity_std, irb_layer_fidelity=irb_layer_fidelity, irb_layer_fidelity_std=irb_layer_fidelity_std, - interleaved_gate_error=interleaved_gate_error, - interleaved_gate_error_std=interleaved_gate_error_std, + average_interleaved_gate_error=interleaved_gate_error, + average_interleaved_gate_error_std=interleaved_gate_error_std, ) if plot_results: diff --git a/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py b/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py index 42706f7d0..00145c7e4 100644 --- a/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py +++ b/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py @@ -255,7 +255,9 @@ def test_analyse_results(irb_experiment: IRB) -> None: assert irb_experiment.results.rb_layer_fidelity == pytest.approx(0.95) assert irb_experiment.results.irb_layer_fidelity == pytest.approx(0.8) - assert irb_experiment.results.interleaved_gate_error == pytest.approx(1 - 0.8 / 0.95) + assert irb_experiment.results.average_interleaved_gate_error == pytest.approx( + 0.5 * (1 - 0.8 / 0.95) + ) # Test that plotting results doesn't introduce any errors. irb_experiment.plot_results() diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb index 6be949d5b..f562d7de1 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb @@ -23,19 +23,38 @@ "outputs": [], "source": [ "import cirq\n", - "noise = cirq.AmplitudeDampingChannel(gamma=0.01)\n", + "import numpy as np\n", + "decay_prob = 0.01\n", + "noise = cirq.AmplitudeDampingChannel(gamma=decay_prob)\n", "target = cirq.DensityMatrixSimulator(noise=noise)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is known that an amplitude damping channel with decay probability $\\gamma$ leads to a gate error\n", + "$$\\frac13 + \\frac{\\gamma}{6} - \\frac{\\sqrt{1-\\gamma}}{3}$$" + ] + }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "expected_gate_error = 1/3 + decay_prob/6 - np.sqrt(1-decay_prob)/3" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ecec67c03e9f40f4b04d269bba12d183", + "model_id": "253cdd27dffd41e5ad90044691819d29", "version_major": 2, "version_minor": 0 }, @@ -49,7 +68,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e5018f0e7b254e7b99995e9f93f6840b", + "model_id": "3c600ff3289f4d7c91efc43656e458d1", "version_major": 2, "version_minor": 0 }, @@ -64,28 +83,28 @@ "source": [ "from cirq_superstaq.qcvv import IRB\n", "\n", - "experiment = IRB(cirq.ops.SingleQubitCliffordGate.I)\n", + "experiment = IRB()\n", "experiment.run(100, [1, 10, 25, 50, 75, 100], target=target)" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "IRBResults(rb_layer_fidelity=0.9933379773690814, rb_layer_fidelity_std=5.828185233898671e-05, irb_layer_fidelity=0.9864546615326705, irb_layer_fidelity_std=0.00016400684889144213, interleaved_gate_error=0.006929480190258852, interleaved_gate_error_std=1.2217226812969893e-06)" + "IRBResults(rb_layer_fidelity=0.9933663340897436, rb_layer_fidelity_std=5.841769504420766e-05, irb_layer_fidelity=0.9866314142548303, irb_layer_fidelity_std=0.00016249287958307833, average_interleaved_gate_error=0.003389947697938045, average_interleaved_gate_error_std=5.928307527842737e-07)" ] }, - "execution_count": 14, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -97,6 +116,25 @@ "source": [ "experiment.analyse_results()" ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Expected gate error: 0.0033375209644599946\n", + "Measured gate error: 0.003389947697938045\n" + ] + } + ], + "source": [ + "print(f\"Expected gate error: {expected_gate_error}\")\n", + "print(f\"Measured gate error: {experiment.results.average_interleaved_gate_error}\")" + ] } ], "metadata": { From 4aad5be5a33a700b6a3ae9a81e0f5a242fc4294c Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Tue, 16 Jul 2024 14:14:37 +0100 Subject: [PATCH 22/32] nit: fix format --- supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb index f562d7de1..674786cbb 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb @@ -24,6 +24,7 @@ "source": [ "import cirq\n", "import numpy as np\n", + "\n", "decay_prob = 0.01\n", "noise = cirq.AmplitudeDampingChannel(gamma=decay_prob)\n", "target = cirq.DensityMatrixSimulator(noise=noise)" @@ -43,7 +44,7 @@ "metadata": {}, "outputs": [], "source": [ - "expected_gate_error = 1/3 + decay_prob/6 - np.sqrt(1-decay_prob)/3" + "expected_gate_error = 1 / 3 + decay_prob / 6 - np.sqrt(1 - decay_prob) / 3" ] }, { From 5da72d66ff2790b3417b2fff5ce2c8b98902db53 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Tue, 16 Jul 2024 14:39:15 +0100 Subject: [PATCH 23/32] nit: init return none --- cirq-superstaq/cirq_superstaq/qcvv/irb.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cirq-superstaq/cirq_superstaq/qcvv/irb.py b/cirq-superstaq/cirq_superstaq/qcvv/irb.py index 927dd18a9..d17dfbc04 100644 --- a/cirq-superstaq/cirq_superstaq/qcvv/irb.py +++ b/cirq-superstaq/cirq_superstaq/qcvv/irb.py @@ -80,7 +80,7 @@ def __init__( self, interleaved_gate: cirq.ops.SingleQubitCliffordGate = cirq.ops.SingleQubitCliffordGate.Z, num_qubits: int = 1, - ): + ) -> None: """Args: interleaved_gate: The Clifford gate to measure the gate error of. num_qubits: The number of qubits to experiment on From 08c7af74b049e56e66ce18226fa84fb4d0ff1472 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Mon, 5 Aug 2024 10:25:39 +0100 Subject: [PATCH 24/32] tie up lose ends --- .../examples/qcvv/qcvv_css.ipynb | 45 ++++++++++------ .../examples/qcvv/qcvv_irb_css.ipynb | 39 +++++++------- .../supermarq/qcvv/__init__.py | 5 ++ .../supermarq/qcvv/base_experiment.py | 28 +++++----- .../supermarq/qcvv/base_experiment_test.py | 22 +++++--- .../supermarq}/qcvv/irb.py | 54 +++++++++++-------- .../supermarq}/qcvv/irb_test.py | 15 ++++-- 7 files changed, 124 insertions(+), 84 deletions(-) rename {cirq-superstaq/cirq_superstaq => supermarq-benchmarks/supermarq}/qcvv/irb.py (86%) rename {cirq-superstaq/cirq_superstaq => supermarq-benchmarks/supermarq}/qcvv/irb_test.py (94%) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index 5b302d37e..e53561e37 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -29,9 +29,18 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", @@ -40,11 +49,11 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample, QCVVResults\n", + "from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample, BenchmarkingResults\n", "from dataclasses import dataclass\n", "from collections.abc import Sequence\n", "from typing import Iterable\n", @@ -60,10 +69,12 @@ "\n", "\n", "@dataclass(frozen=True)\n", - "class NaiveExperimentResult(QCVVResults):\n", + "class NaiveExperimentResult(BenchmarkingResults):\n", " gate_fidelity: float\n", " gate_error: float\n", "\n", + " experiment_name = \"NaiveExperiment\"\n", + "\n", "\n", "class NaiveExperiment(BenchmarkingExperiment):\n", " def __init__(self):\n", @@ -137,13 +148,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "01239511c7da4cdba676345288a220b5", + "model_id": "2b929a60c931400bad916bd49f04cfa4", "version_major": 2, "version_minor": 0 }, @@ -157,7 +168,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "55291d63fe3343e0b345fddcd7c341c4", + "model_id": "323eb643e2ea42c19f600e1032df0bb8", "version_major": 2, "version_minor": 0 }, @@ -178,19 +189,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "NaiveExperimentResult(experiment_name='Naive Experiment', target='Local simulator', total_circuits=30, gate_fidelity=0.9862489774018681, gate_error=0.013751022598131879)\n" + "NaiveExperimentResult(experiment_name='Naive Experiment', target='Local simulator', total_circuits=30, gate_fidelity=0.985976601929455, gate_error=0.014023398070544979)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -214,14 +225,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.01031326694859891\n" + "0.010517548552908734\n" ] } ], @@ -249,13 +260,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0adc5543d95b43eda6eed66876983e8e", + "model_id": "6d9aa2b922b5447489b23be4cd881556", "version_major": 2, "version_minor": 0 }, @@ -275,13 +286,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f8275dbc8a124d7aa5304baf65bd290e", + "model_id": "00b371e0af09461db1dbb00cc66578f9", "version_major": 2, "version_minor": 0 }, diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb index 674786cbb..b36fad3d3 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -49,13 +49,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "253cdd27dffd41e5ad90044691819d29", + "model_id": "ec38b4dfc33a45c9b55ae2b910ddeffd", "version_major": 2, "version_minor": 0 }, @@ -69,7 +69,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3c600ff3289f4d7c91efc43656e458d1", + "model_id": "537c739c0d674193830576aeb1cdafa9", "version_major": 2, "version_minor": 0 }, @@ -82,30 +82,27 @@ } ], "source": [ - "from cirq_superstaq.qcvv import IRB\n", + "from supermarq.qcvv import IRB\n", "\n", "experiment = IRB()\n", - "experiment.run(100, [1, 10, 25, 50, 75, 100], target=target)" + "experiment.run_with_simulator(100, [1, 10, 25, 50, 75, 100], target=target)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "IRBResults(rb_layer_fidelity=0.9933663340897436, rb_layer_fidelity_std=5.841769504420766e-05, irb_layer_fidelity=0.9866314142548303, irb_layer_fidelity_std=0.00016249287958307833, average_interleaved_gate_error=0.003389947697938045, average_interleaved_gate_error_std=5.928307527842737e-07)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "IRBResults(target=['Local simulator'], total_circuits=1200, experiment_name='IRB', rb_layer_fidelity=0.9933653437478775, rb_layer_fidelity_std=5.652788049644502e-05, irb_layer_fidelity=0.9868154592201566, irb_layer_fidelity_std=0.00018582763901399624, average_interleaved_gate_error=0.003296815501439232, average_interleaved_gate_error_std=6.485519397757938e-07)\n" + ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -115,12 +112,14 @@ } ], "source": [ - "experiment.analyse_results()" + "if experiment.collect_data():\n", + " results = experiment.analyse_results(plot_results=True)\n", + " print(results)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -128,7 +127,7 @@ "output_type": "stream", "text": [ "Expected gate error: 0.0033375209644599946\n", - "Measured gate error: 0.003389947697938045\n" + "Measured gate error: 0.003296815501439232\n" ] } ], diff --git a/supermarq-benchmarks/supermarq/qcvv/__init__.py b/supermarq-benchmarks/supermarq/qcvv/__init__.py index 4c0a5dc54..9887ede35 100644 --- a/supermarq-benchmarks/supermarq/qcvv/__init__.py +++ b/supermarq-benchmarks/supermarq/qcvv/__init__.py @@ -1 +1,6 @@ """A toolkit of QCVV routines.""" + +from .base_experiment import BenchmarkingExperiment, BenchmarkingResults, Sample +from .irb import IRB, IRBResults + +__all__ = ["BenchmarkingExperiment", "BenchmarkingResults", "Sample", "IRB", "IRBResults"] diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index 5e0510169..4dda61453 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -62,17 +62,18 @@ def target(self) -> str: @dataclass(frozen=True) -class QCVVResults: +class BenchmarkingResults(ABC): """A dataclass for storing the results of the experiment. Requires subclassing for each new experiment type""" - experiment_name: str - """The name of the experiment.""" target: str """The target device that was used.""" total_circuits: int """The total number of circuits used in the experiment.""" + experiment_name: str = field(init=False) + """The name of the experiment""" + class BenchmarkingExperiment(ABC): """Base class for gate benchmarking experiments. @@ -106,7 +107,7 @@ class BenchmarkingExperiment(ABC): results = experiment.analyse_results(<>) #. The final results of the experiment will be stored in the :code:`results` attribute as a - :class:`QCVVResults` of values, while all the data from the experiment will be + :class:`BenchmarkingResults` of values, while all the data from the experiment will be stored in the :code:`raw_data` attribute as a :class:`~pandas.DataFrame`. Some experiments may include additional data attributes for data generated during the analysis. @@ -130,14 +131,13 @@ class BenchmarkingExperiment(ABC): into a :class:`pandas.DataFrame`. #. :meth:`analyse_results`: Analyse the data in the :attr:`raw_data` dataframe and return a - :class:`QCVVResults` object containing the results of the experiment. + :class:`BenchmarkingResults` object containing the results of the experiment. #. :meth:`plot_results`: Produce any relevant plots that are useful for understanding the results of the experiment. - Additionally the :class:`QCVVResults` dataclass needs subclassing to hold the specific results - of the new experiment. - + Additionally the :class:`BenchmarkingResults` dataclass needs subclassing to hold the specific + results of the new experiment. """ def __init__( @@ -156,7 +156,7 @@ def __init__( self._raw_data: pd.DataFrame | None = None "The data generated during the experiment" - self._results: QCVVResults | None = None + self._results: BenchmarkingResults | None = None """The attribute to store the results in.""" self._samples: Sequence[Sample] | None = None @@ -166,7 +166,7 @@ def __init__( """The superstaq service for submitting jobs.""" @property - def results(self) -> QCVVResults: + def results(self) -> BenchmarkingResults: """The results from the most recently run experiment. Raises: @@ -218,8 +218,10 @@ def sample_targets(self) -> list[str]: def _validate_circuits(self) -> None: """Checks that all circuits contain a terminal measurement of all qubits.""" for sample in self.samples: + if not sample.circuit.has_measurements(): + raise ValueError("QCVV experiment circuits must contain measurements.") if not sample.circuit.are_all_measurements_terminal(): - raise ValueError("QCVV experiment circuits can only contain terminal measurements") + raise ValueError("QCVV experiment circuits can only contain terminal measurements.") if not sorted(sample.circuit[-1].qubits) == sorted(self.qubits): raise ValueError( "The terminal measurement in QCVV experiment circuits must measure all qubits." @@ -432,7 +434,7 @@ def build_circuits( cycle_depths: An iterable of the different cycle depths to use during the experiment. Returns: - The list of circuit objects + The list of experiment samples. """ @abstractmethod @@ -452,7 +454,7 @@ def plot_results(self) -> None: """Plot the results of the experiment""" @abstractmethod - def analyse_results(self, plot_results: bool = True) -> QCVVResults: + def analyse_results(self, plot_results: bool = True) -> BenchmarkingResults: """Perform the experiment analysis and store the results in the `results` attribute Args: diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index 8022e5b95..e274d5280 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -27,7 +27,7 @@ import pandas as pd import pytest -from supermarq.qcvv.base_experiment import BenchmarkingExperiment, QCVVResults, Sample +from supermarq.qcvv.base_experiment import BenchmarkingExperiment, BenchmarkingResults, Sample @pytest.fixture(scope="session", autouse=True) @@ -50,16 +50,18 @@ def sample_circuits() -> list[Sample]: circuit=cirq.Circuit(cirq.CZ(*qubits), cirq.CZ(*qubits), cirq.measure(*qubits)), data={"circuit": 1}, ), - Sample(circuit=cirq.Circuit(cirq.CX(*qubits)), data={"circuit": 2}), + Sample(circuit=cirq.Circuit(cirq.CX(*qubits), cirq.measure(*qubits)), data={"circuit": 2}), ] @dataclass(frozen=True) -class ExampleResults(QCVVResults): +class ExampleResults(BenchmarkingResults): """NamedTuple instance to use for testing""" example: float + experiment_name = "Example results" + def test_sample_target_property() -> None: sample = Sample(circuit=MagicMock(), data={}) @@ -80,9 +82,7 @@ def test_benchmarking_experiment_init(abc_experiment: BenchmarkingExperiment) -> assert abc_experiment._samples is None abc_experiment._raw_data = pd.DataFrame([{"Example": 0.1}]) - abc_experiment._results = ExampleResults( - experiment_name="Example", target="Some target", total_circuits=2, example=5.0 - ) + abc_experiment._results = ExampleResults(target="Some target", total_circuits=2, example=5.0) pd.testing.assert_frame_equal(abc_experiment.raw_data, abc_experiment._raw_data) assert abc_experiment.results == abc_experiment._results @@ -325,7 +325,7 @@ def test_validate_circuits( # Add a gate so not all measurements are terminal abc_experiment._samples[0].circuit += cirq.X(abc_experiment.qubits[0]) with pytest.raises( - ValueError, match="QCVV experiment circuits can only contain terminal measurements" + ValueError, match="QCVV experiment circuits can only contain terminal measurements." ): abc_experiment._validate_circuits() @@ -339,6 +339,14 @@ def test_validate_circuits( ): abc_experiment._validate_circuits() + # Remove all measurements + abc_experiment._samples[0].circuit = abc_experiment._samples[0].circuit[:-2] + with pytest.raises( + ValueError, + match="QCVV experiment circuits must contain measurements.", + ): + abc_experiment._validate_circuits() + def test_process_device_counts(abc_experiment: BenchmarkingExperiment) -> None: counts = { diff --git a/cirq-superstaq/cirq_superstaq/qcvv/irb.py b/supermarq-benchmarks/supermarq/qcvv/irb.py similarity index 86% rename from cirq-superstaq/cirq_superstaq/qcvv/irb.py rename to supermarq-benchmarks/supermarq/qcvv/irb.py index d17dfbc04..868f7de72 100644 --- a/cirq-superstaq/cirq_superstaq/qcvv/irb.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb.py @@ -17,7 +17,7 @@ import random from collections.abc import Iterable, Sequence -from typing import NamedTuple, cast +from dataclasses import dataclass import cirq import numpy as np @@ -26,10 +26,11 @@ from scipy.stats import linregress from tqdm.contrib.itertools import product -from cirq_superstaq.qcvv.base_experiment import BenchmarkingExperiment, Sample +from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample, BenchmarkingResults -class IRBResults(NamedTuple): +@dataclass(frozen=True) +class IRBResults(BenchmarkingResults): """Data structure for the IRB experiment results.""" rb_layer_fidelity: float @@ -45,6 +46,8 @@ class IRBResults(NamedTuple): average_interleaved_gate_error_std: float """Standard deviation of the estimate for the interleaving gate error.""" + experiment_name = "IRB" + class IRB(BenchmarkingExperiment): r"""Interleaved random benchmarking (IRB) experiment. @@ -72,7 +75,7 @@ class IRB(BenchmarkingExperiment): .. math:: - e_{\mathcal{C}^*} = 1 - \frac{\tilde{\alpha}}{\alpha} + e_{\mathcal{C}^*} = \frac{1}{2} \left(1 - \frac{\tilde{\alpha}}{\alpha}\right) """ @@ -94,11 +97,6 @@ def __init__( self.interleaved_gate = interleaved_gate """The gate being interleaved""" - @property - def results(self) -> IRBResults: - """The results from the most recently run experiment""" - return cast("IRBResults", super().results) - @staticmethod def _reduce_clifford_seq( gate_seq: list[cirq.ops.SingleQubitCliffordGate], @@ -159,20 +157,18 @@ def _invert_clifford_circuit(self, circuit: cirq.Circuit) -> cirq.Circuit: clifford_gates.append(inv_element) return cirq.Circuit(*[gate(*self.qubits) for gate in clifford_gates]) # type: ignore[misc] - def build_circuits(self, num_circuits: int, layers: Iterable[int]) -> Sequence[Sample]: + def build_circuits(self, num_circuits: int, cycle_depths: Iterable[int]) -> Sequence[Sample]: """Build a list of randomised circuits required for the IRB experiment. - These circuits do not include the interleaving gate or the final inverse - gate, instead these are added in the :meth:`sample_circuit` function. Args: num_circuits: Number of circuits to generate. - layers: TODO + cycle_depths: An iterable of the different cycle depths to use during the experiment. Returns: - TODO + The list of experiment samples. """ samples = [] - for _, depth in product(range(num_circuits), layers, desc="Building circuits"): + for _, depth in product(range(num_circuits), cycle_depths, desc="Building circuits"): base_circuit = cirq.Circuit( *[self._random_single_qubit_clifford()(*self.qubits) for _ in range(depth)] ) @@ -182,7 +178,7 @@ def build_circuits(self, num_circuits: int, layers: Iterable[int]) -> Sequence[S ) samples += [ Sample( - circuit=rb_circuit, + circuit=rb_circuit + cirq.measure(sorted(rb_circuit.all_qubits())), data={ "num_cycles": depth, "circuit_depth": len(rb_circuit), @@ -190,7 +186,7 @@ def build_circuits(self, num_circuits: int, layers: Iterable[int]) -> Sequence[S }, ), Sample( - circuit=irb_circuit, + circuit=irb_circuit + cirq.measure(sorted(irb_circuit.all_qubits())), data={ "num_cycles": depth, "circuit_depth": len(irb_circuit), @@ -201,14 +197,19 @@ def build_circuits(self, num_circuits: int, layers: Iterable[int]) -> Sequence[S return samples - def process_probabilities(self) -> None: + def process_probabilities(self, samples: Sequence[Sample]) -> pd.DataFrame: """Processes the probabilities generated by sampling the circuits into the data structures needed for analyzing the results. + + Args: + samples: The list of samples to process the results from. + + Returns: + A data frame of the full results needed to analyse the experiment. """ - super().process_probabilities() records = [] - for sample in self.samples: + for sample in samples: records.append( { "clifford_depth": sample.data["num_cycles"], @@ -218,7 +219,7 @@ def process_probabilities(self) -> None: } ) - self._raw_data = pd.DataFrame(records) + return pd.DataFrame(records) def plot_results(self) -> None: """Plot the exponential decay of the circuit fidelity with @@ -237,7 +238,14 @@ def plot_results(self) -> None: ax.set_title(r"Exponential decay of circuit fidelity", fontsize=15) def analyse_results(self, plot_results: bool = True) -> IRBResults: - """Analyse the experiment results and estimate the interleaved gate error.""" + """Analyse the experiment results and estimate the interleaved gate error. + + Args: + plot_results: Whether to generate plots of the results. Defaults to False. + + Returns: + A named tuple of the final results from the experiment. + """ self.raw_data["fidelity"] = 2 * self.raw_data["0"] - 1 self.raw_data["log_fidelity"] = np.log(self.raw_data["fidelity"]) @@ -264,6 +272,8 @@ def analyse_results(self, plot_results: bool = True) -> IRBResults: ) self._results = IRBResults( + target=self.sample_targets, + total_circuits=len(self.samples), rb_layer_fidelity=rb_layer_fidelity, rb_layer_fidelity_std=rb_layer_fidelity_std, irb_layer_fidelity=irb_layer_fidelity, diff --git a/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py b/supermarq-benchmarks/supermarq/qcvv/irb_test.py similarity index 94% rename from cirq-superstaq/cirq_superstaq/qcvv/irb_test.py rename to supermarq-benchmarks/supermarq/qcvv/irb_test.py index 00145c7e4..cf43e5bbc 100644 --- a/cirq-superstaq/cirq_superstaq/qcvv/irb_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb_test.py @@ -11,6 +11,7 @@ # See the License for the specific language governing permissions and # limitations under the License. # pylint: disable=missing-function-docstring +# pylint: disable=missing-return-doc # mypy: disable-error-code=method-assign from __future__ import annotations @@ -21,8 +22,8 @@ import pandas as pd import pytest -from cirq_superstaq.qcvv.base_experiment import Sample -from cirq_superstaq.qcvv.irb import IRB +from supermarq.qcvv.base_experiment import Sample +from supermarq.qcvv.irb import IRB @pytest.fixture(scope="session", autouse=True) @@ -90,9 +91,8 @@ def test_irb_process_probabilities(irb_experiment: IRB) -> None: ) ] samples[0].probabilities = {"00": 0.1, "01": 0.2, "10": 0.3, "11": 0.4} - irb_experiment._samples = samples - irb_experiment.process_probabilities() + data = irb_experiment.process_probabilities(samples) expected_data = pd.DataFrame( [ @@ -108,7 +108,7 @@ def test_irb_process_probabilities(irb_experiment: IRB) -> None: ] ) - pd.testing.assert_frame_equal(expected_data, irb_experiment.raw_data) + pd.testing.assert_frame_equal(expected_data, data) def test_irb_build_circuit(irb_experiment: IRB) -> None: @@ -131,6 +131,7 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.measure(irb_experiment.qubits), ] ), data={ @@ -149,6 +150,7 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.I(*irb_experiment.qubits), + cirq.measure(irb_experiment.qubits), ] ), data={ @@ -164,6 +166,7 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), + cirq.measure(irb_experiment.qubits), ] ), data={ @@ -182,6 +185,7 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.Y(*irb_experiment.qubits), + cirq.measure(irb_experiment.qubits), ] ), data={ @@ -205,6 +209,7 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: def test_analyse_results(irb_experiment: IRB) -> None: + irb_experiment._samples = MagicMock() irb_experiment._raw_data = pd.DataFrame( [ { From 075336706542a7d4a38976a846cc43bca468f897 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Mon, 5 Aug 2024 10:37:33 +0100 Subject: [PATCH 25/32] Nit: formatting and mock css.service in irb test --- supermarq-benchmarks/supermarq/qcvv/irb.py | 2 +- supermarq-benchmarks/supermarq/qcvv/irb_test.py | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/irb.py b/supermarq-benchmarks/supermarq/qcvv/irb.py index 868f7de72..b6ee00851 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb.py @@ -26,7 +26,7 @@ from scipy.stats import linregress from tqdm.contrib.itertools import product -from supermarq.qcvv.base_experiment import BenchmarkingExperiment, Sample, BenchmarkingResults +from supermarq.qcvv.base_experiment import BenchmarkingExperiment, BenchmarkingResults, Sample @dataclass(frozen=True) diff --git a/supermarq-benchmarks/supermarq/qcvv/irb_test.py b/supermarq-benchmarks/supermarq/qcvv/irb_test.py index cf43e5bbc..d28ac1292 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb_test.py @@ -16,7 +16,7 @@ from __future__ import annotations import os -from unittest.mock import MagicMock +from unittest.mock import MagicMock, patch import cirq import pandas as pd @@ -46,7 +46,8 @@ def test_irb_init() -> None: @pytest.fixture def irb_experiment() -> IRB: - return IRB() + with patch("cirq_superstaq.service.Service"): + return IRB() def test_reduce_clifford_sequence() -> None: From 52d95b69fa26c875cb088f6add7d9e09d0793424 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Mon, 5 Aug 2024 10:59:39 +0100 Subject: [PATCH 26/32] Fix: Add generic type to base qcvv framework to facilitate subclassing results dataclass --- .../examples/qcvv/qcvv_css.ipynb | 48 ++++------- .../supermarq/qcvv/base_experiment.py | 13 +-- .../supermarq/qcvv/base_experiment_test.py | 80 ++++++++++--------- supermarq-benchmarks/supermarq/qcvv/irb.py | 4 +- 4 files changed, 69 insertions(+), 76 deletions(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb index e53561e37..bf62baa12 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_css.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -76,7 +76,7 @@ " experiment_name = \"NaiveExperiment\"\n", "\n", "\n", - "class NaiveExperiment(BenchmarkingExperiment):\n", + "class NaiveExperiment(BenchmarkingExperiment[NaiveExperimentResult]):\n", " def __init__(self):\n", " super().__init__(num_qubits=1)\n", "\n", @@ -109,7 +109,6 @@ " fidelity = np.exp(model.slope)\n", "\n", " self._results = NaiveExperimentResult(\n", - " experiment_name=\"Naive Experiment\",\n", " target=\"& \".join(self.sample_targets),\n", " total_circuits=len(self.samples),\n", " gate_fidelity=fidelity,\n", @@ -148,13 +147,13 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2b929a60c931400bad916bd49f04cfa4", + "model_id": "68929af4f17b4528a9c95ad76a177a8a", "version_major": 2, "version_minor": 0 }, @@ -168,7 +167,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "323eb643e2ea42c19f600e1032df0bb8", + "model_id": "e55dbcef96a54a959bdb7dcf2cb7a989", "version_major": 2, "version_minor": 0 }, @@ -189,19 +188,19 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "NaiveExperimentResult(experiment_name='Naive Experiment', target='Local simulator', total_circuits=30, gate_fidelity=0.985976601929455, gate_error=0.014023398070544979)\n" + "NaiveExperimentResult(target='Local simulator', total_circuits=30, experiment_name='NaiveExperiment', gate_fidelity=0.9861173576577176, gate_error=0.013882642342282425)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -225,14 +224,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.010517548552908734\n" + "0.010411981756711819\n" ] } ], @@ -260,13 +259,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6d9aa2b922b5447489b23be4cd881556", + "model_id": "33fb19ab9e494ab7ba76739f50e819ae", "version_major": 2, "version_minor": 0 }, @@ -286,13 +285,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "00b371e0af09461db1dbb00cc66578f9", + "model_id": "8d579026bbb540d7aa47e42fcb4c3771", "version_major": 2, "version_minor": 0 }, @@ -302,23 +301,6 @@ }, "metadata": {}, "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "NaiveExperimentResult(experiment_name='Naive Experiment', target='ss_unconstrained_simulator', total_circuits=15, gate_fidelity=1.0, gate_error=0.0)\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index 4dda61453..caaad2c67 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -18,7 +18,7 @@ from abc import ABC, abstractmethod from collections.abc import Iterable, Sequence from dataclasses import dataclass, field -from typing import Any +from typing import Any, Generic, TypeVar import cirq import cirq_superstaq as css @@ -75,7 +75,10 @@ class BenchmarkingResults(ABC): """The name of the experiment""" -class BenchmarkingExperiment(ABC): +ResultsT = TypeVar("ResultsT", bound="BenchmarkingResults") + + +class BenchmarkingExperiment(ABC, Generic[ResultsT]): """Base class for gate benchmarking experiments. The interface for implementing these experiments is as follows: @@ -156,7 +159,7 @@ def __init__( self._raw_data: pd.DataFrame | None = None "The data generated during the experiment" - self._results: BenchmarkingResults | None = None + self._results: ResultsT | None = None """The attribute to store the results in.""" self._samples: Sequence[Sample] | None = None @@ -166,7 +169,7 @@ def __init__( """The superstaq service for submitting jobs.""" @property - def results(self) -> BenchmarkingResults: + def results(self) -> ResultsT: """The results from the most recently run experiment. Raises: @@ -454,7 +457,7 @@ def plot_results(self) -> None: """Plot the results of the experiment""" @abstractmethod - def analyse_results(self, plot_results: bool = True) -> BenchmarkingResults: + def analyse_results(self, plot_results: bool = True) -> ResultsT: """Perform the experiment analysis and store the results in the `results` attribute Args: diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py index e274d5280..a819dbc44 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment_test.py @@ -30,6 +30,15 @@ from supermarq.qcvv.base_experiment import BenchmarkingExperiment, BenchmarkingResults, Sample +@dataclass(frozen=True) +class ExampleResults(BenchmarkingResults): + """NamedTuple instance to use for testing""" + + example: float + + experiment_name = "Example results" + + @pytest.fixture(scope="session", autouse=True) def patch_tqdm() -> None: os.environ["TQDM_DISABLE"] = "1" @@ -37,7 +46,7 @@ def patch_tqdm() -> None: @pytest.fixture @patch.multiple(BenchmarkingExperiment, __abstractmethods__=set()) -def abc_experiment() -> BenchmarkingExperiment: +def abc_experiment() -> BenchmarkingExperiment[ExampleResults]: with patch("cirq_superstaq.service.Service"): return BenchmarkingExperiment(num_qubits=2) # type: ignore[abstract] @@ -54,15 +63,6 @@ def sample_circuits() -> list[Sample]: ] -@dataclass(frozen=True) -class ExampleResults(BenchmarkingResults): - """NamedTuple instance to use for testing""" - - example: float - - experiment_name = "Example results" - - def test_sample_target_property() -> None: sample = Sample(circuit=MagicMock(), data={}) assert sample.target == "No target" @@ -75,7 +75,9 @@ def test_sample_target_property() -> None: assert sample.target == "Example target" -def test_benchmarking_experiment_init(abc_experiment: BenchmarkingExperiment) -> None: +def test_benchmarking_experiment_init( + abc_experiment: BenchmarkingExperiment[ExampleResults], +) -> None: assert abc_experiment.num_qubits == 2 assert abc_experiment._raw_data is None assert abc_experiment._results is None @@ -88,26 +90,28 @@ def test_benchmarking_experiment_init(abc_experiment: BenchmarkingExperiment) -> assert abc_experiment.results == abc_experiment._results -def test_empty_results_error(abc_experiment: BenchmarkingExperiment) -> None: +def test_empty_results_error(abc_experiment: BenchmarkingExperiment[ExampleResults]) -> None: with pytest.raises( RuntimeError, match="No results to retrieve. The experiment has not been run." ): _ = abc_experiment.results -def test_empty_data_error(abc_experiment: BenchmarkingExperiment) -> None: +def test_empty_data_error(abc_experiment: BenchmarkingExperiment[ExampleResults]) -> None: with pytest.raises(RuntimeError, match="No data to retrieve. The experiment has not been run."): _ = abc_experiment.raw_data -def test_empty_samples_error(abc_experiment: BenchmarkingExperiment) -> None: +def test_empty_samples_error(abc_experiment: BenchmarkingExperiment[ExampleResults]) -> None: with pytest.raises( RuntimeError, match="No samples to retrieve. The experiment has not been run." ): _ = abc_experiment.samples -def test_prepare_experiment_overwrite_error(abc_experiment: BenchmarkingExperiment) -> None: +def test_prepare_experiment_overwrite_error( + abc_experiment: BenchmarkingExperiment[ExampleResults], +) -> None: abc_experiment._samples = [Sample(circuit=MagicMock(), data={})] abc_experiment.build_circuits = MagicMock() @@ -119,7 +123,9 @@ def test_prepare_experiment_overwrite_error(abc_experiment: BenchmarkingExperime abc_experiment._prepare_experiment(100, [1, 50, 100]) -def test_prepare_experiment_overwrite(abc_experiment: BenchmarkingExperiment) -> None: +def test_prepare_experiment_overwrite( + abc_experiment: BenchmarkingExperiment[ExampleResults], +) -> None: abc_experiment._samples = [Sample(circuit=MagicMock(), data={})] abc_experiment.build_circuits = MagicMock() abc_experiment._validate_circuits = MagicMock() @@ -130,7 +136,9 @@ def test_prepare_experiment_overwrite(abc_experiment: BenchmarkingExperiment) -> abc_experiment._validate_circuits.assert_called_once_with() -def test_prepare_experiment_with_bad_layers(abc_experiment: BenchmarkingExperiment) -> None: +def test_prepare_experiment_with_bad_layers( + abc_experiment: BenchmarkingExperiment[ExampleResults], +) -> None: with pytest.raises( ValueError, match="The `cycle_depths` iterator can only include positive values." ): @@ -138,7 +146,7 @@ def test_prepare_experiment_with_bad_layers(abc_experiment: BenchmarkingExperime def test_run_with_simulator( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: cirq.measurement_key_name = MagicMock() abc_experiment._prepare_experiment = MagicMock() @@ -167,7 +175,7 @@ def test_run_with_simulator( def test_run_with_simulator_default_target( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: cirq.measurement_key_name = MagicMock() cirq.Simulator = (target := MagicMock()) # type: ignore [misc] @@ -196,7 +204,7 @@ def test_run_with_simulator_default_target( def test_run_on_device( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: abc_experiment._prepare_experiment = MagicMock() abc_experiment._samples = sample_circuits @@ -220,7 +228,7 @@ def test_run_on_device( def test_run_on_device_dry_run( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: abc_experiment._prepare_experiment = MagicMock() abc_experiment._samples = sample_circuits @@ -239,7 +247,7 @@ def test_run_on_device_dry_run( assert job == mock_service.create_job.return_value -def test_state_probs_to_dict(abc_experiment: BenchmarkingExperiment) -> None: +def test_state_probs_to_dict(abc_experiment: BenchmarkingExperiment[ExampleResults]) -> None: probabilities = np.array([0.1, 0.2, 0.3, 0.4]) out_dict = abc_experiment._state_probs_to_dict(probabilities) assert out_dict == { @@ -291,7 +299,7 @@ def test_interleave_circuit() -> None: def test_sample_statuses( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits mock_job = MagicMock(spec=css.Job) @@ -304,7 +312,7 @@ def test_sample_statuses( def test_sample_targets( - abc_experiment: BenchmarkingExperiment, + abc_experiment: BenchmarkingExperiment[ExampleResults], ) -> None: abc_experiment._samples = [mock_sample_0 := MagicMock(), mock_sample_1 := MagicMock()] mock_sample_0.target = "target_0" @@ -316,7 +324,7 @@ def test_sample_targets( def test_validate_circuits( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits # Should't get any errors with the base circuits @@ -348,7 +356,7 @@ def test_validate_circuits( abc_experiment._validate_circuits() -def test_process_device_counts(abc_experiment: BenchmarkingExperiment) -> None: +def test_process_device_counts(abc_experiment: BenchmarkingExperiment[ExampleResults]) -> None: counts = { "00": 20, "01": 5, @@ -360,7 +368,7 @@ def test_process_device_counts(abc_experiment: BenchmarkingExperiment) -> None: def test_retrieve_ss_jobs_not_all_submitted( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits @@ -377,7 +385,7 @@ def test_retrieve_ss_jobs_not_all_submitted( def test_retrieve_ss_jobs_nothing_to_retrieve( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits statuses = abc_experiment.retrieve_ss_jobs() @@ -385,7 +393,7 @@ def test_retrieve_ss_jobs_nothing_to_retrieve( def test_retrieve_ss_jobs_all_submitted( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits mock_job_1 = MagicMock(spec=css.Job) @@ -411,13 +419,13 @@ def test_retrieve_ss_jobs_all_submitted( assert not hasattr(sample_circuits[0], "probabilities") -def test_collect_data_no_samples(abc_experiment: BenchmarkingExperiment) -> None: +def test_collect_data_no_samples(abc_experiment: BenchmarkingExperiment[ExampleResults]) -> None: with pytest.raises(RuntimeError, match="The experiment has not yet ben run."): abc_experiment.collect_data() def test_collect_data_no_jobs_to_retrieve( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: sample_circuits[0].probabilities = {"00": 1.0, "10": 0.0, "01": 0.0, "11": 0.0} sample_circuits[1].probabilities = {"00": 0.0, "10": 0.0, "01": 0.0, "11": 1.0} @@ -429,7 +437,7 @@ def test_collect_data_no_jobs_to_retrieve( def test_collect_data_no_jobs_to_retrieve_not_all_probabilities( - abc_experiment: BenchmarkingExperiment, + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample], capfd: pytest.CaptureFixture[str], ) -> None: @@ -444,7 +452,7 @@ def test_collect_data_no_jobs_to_retrieve_not_all_probabilities( def test_collect_data_no_jobs_to_retrieve_not_all_probabilities_forced( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: sample_circuits[0].probabilities = {"00": 1.0, "10": 0.0, "01": 0.0, "11": 0.0} abc_experiment._samples = sample_circuits @@ -455,7 +463,7 @@ def test_collect_data_no_jobs_to_retrieve_not_all_probabilities_forced( def test_collect_data_cannot_force( - abc_experiment: BenchmarkingExperiment, sample_circuits: list[Sample] + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample] ) -> None: abc_experiment._samples = sample_circuits abc_experiment.process_probabilities = MagicMock() @@ -469,7 +477,7 @@ def test_collect_data_cannot_force( def test_collect_data_outstanding_jobs( - abc_experiment: BenchmarkingExperiment, + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample], capfd: pytest.CaptureFixture[str], ) -> None: @@ -487,7 +495,7 @@ def test_collect_data_outstanding_jobs( def test_collect_data_outstanding_jobs_force( - abc_experiment: BenchmarkingExperiment, + abc_experiment: BenchmarkingExperiment[ExampleResults], sample_circuits: list[Sample], capfd: pytest.CaptureFixture[str], ) -> None: diff --git a/supermarq-benchmarks/supermarq/qcvv/irb.py b/supermarq-benchmarks/supermarq/qcvv/irb.py index b6ee00851..27f273bc0 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb.py @@ -49,7 +49,7 @@ class IRBResults(BenchmarkingResults): experiment_name = "IRB" -class IRB(BenchmarkingExperiment): +class IRB(BenchmarkingExperiment[IRBResults]): r"""Interleaved random benchmarking (IRB) experiment. IRB estimates the gate error of specified Clifford gate, :math:`\mathcal{C}^*`. @@ -272,7 +272,7 @@ def analyse_results(self, plot_results: bool = True) -> IRBResults: ) self._results = IRBResults( - target=self.sample_targets, + target="& ".join(self.sample_targets), total_circuits=len(self.samples), rb_layer_fidelity=rb_layer_fidelity, rb_layer_fidelity_std=rb_layer_fidelity_std, From 6b2f8081195fc69bda71eb7541c899a9dc754e85 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Mon, 5 Aug 2024 11:07:48 +0100 Subject: [PATCH 27/32] Patch init --- supermarq-benchmarks/supermarq/qcvv/irb_test.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/irb_test.py b/supermarq-benchmarks/supermarq/qcvv/irb_test.py index d28ac1292..9a73719bf 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb_test.py @@ -32,16 +32,17 @@ def patch_tqdm() -> None: def test_irb_init() -> None: - experiment = IRB() - assert experiment.num_qubits == 1 - assert experiment.interleaved_gate == cirq.ops.SingleQubitCliffordGate.Z + with patch("cirq_superstaq.service.Service"): + experiment = IRB() + assert experiment.num_qubits == 1 + assert experiment.interleaved_gate == cirq.ops.SingleQubitCliffordGate.Z - experiment = IRB(interleaved_gate=cirq.ops.SingleQubitCliffordGate.X) - assert experiment.num_qubits == 1 - assert experiment.interleaved_gate == cirq.ops.SingleQubitCliffordGate.X + experiment = IRB(interleaved_gate=cirq.ops.SingleQubitCliffordGate.X) + assert experiment.num_qubits == 1 + assert experiment.interleaved_gate == cirq.ops.SingleQubitCliffordGate.X - with pytest.raises(NotImplementedError): - IRB(num_qubits=2) + with pytest.raises(NotImplementedError): + IRB(num_qubits=2) @pytest.fixture From b4a38453cba1cf5b903cde7205f4a3098d8f88e0 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Wed, 14 Aug 2024 09:18:59 +0100 Subject: [PATCH 28/32] Align with updated qcvv framework --- .../examples/qcvv/qcvv_irb_css.ipynb | 35 ++++++++-------- supermarq-benchmarks/supermarq/qcvv/irb.py | 27 +++++++------ .../supermarq/qcvv/irb_test.py | 40 ++++++++++++------- 3 files changed, 60 insertions(+), 42 deletions(-) diff --git a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb index b36fad3d3..9cccd5212 100644 --- a/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb +++ b/supermarq-benchmarks/examples/qcvv/qcvv_irb_css.ipynb @@ -25,9 +25,9 @@ "import cirq\n", "import numpy as np\n", "\n", - "decay_prob = 0.01\n", + "decay_prob = 0.05\n", "noise = cirq.AmplitudeDampingChannel(gamma=decay_prob)\n", - "target = cirq.DensityMatrixSimulator(noise=noise)" + "simulator = cirq.DensityMatrixSimulator(noise=noise)" ] }, { @@ -55,12 +55,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ec38b4dfc33a45c9b55ae2b910ddeffd", + "model_id": "d55fb24f5d6843b2baa312983100e4ec", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Building circuits: 0%| | 0/600 [00:00" ] @@ -113,27 +114,29 @@ ], "source": [ "if experiment.collect_data():\n", - " results = experiment.analyse_results(plot_results=True)\n", + " results = experiment.analyze_results(plot_results=True)\n", " print(results)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Expected gate error: 0.0033375209644599946\n", - "Measured gate error: 0.003296815501439232\n" + "Expected gate error: 0.016774\n", + "Measured gate error: 0.015179 +/- 0.001293\n" ] } ], "source": [ - "print(f\"Expected gate error: {expected_gate_error}\")\n", - "print(f\"Measured gate error: {experiment.results.average_interleaved_gate_error}\")" + "print(f\"Expected gate error: {expected_gate_error:.6f}\")\n", + "print(\n", + " f\"Measured gate error: {results.average_interleaved_gate_error:.6f} +/- {results.average_interleaved_gate_error_std:.6f}\"\n", + ")" ] } ], diff --git a/supermarq-benchmarks/supermarq/qcvv/irb.py b/supermarq-benchmarks/supermarq/qcvv/irb.py index 27f273bc0..6d3d9ea52 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb.py @@ -154,10 +154,9 @@ def _invert_clifford_circuit(self, circuit: cirq.Circuit) -> cirq.Circuit: inv_element = self._reduce_clifford_seq( cirq.inverse(clifford_gates) # type: ignore[arg-type] ) - clifford_gates.append(inv_element) - return cirq.Circuit(*[gate(*self.qubits) for gate in clifford_gates]) # type: ignore[misc] + return circuit + inv_element(*self.qubits) - def build_circuits(self, num_circuits: int, cycle_depths: Iterable[int]) -> Sequence[Sample]: + def _build_circuits(self, num_circuits: int, cycle_depths: Iterable[int]) -> Sequence[Sample]: """Build a list of randomised circuits required for the IRB experiment. Args: @@ -174,11 +173,13 @@ def build_circuits(self, num_circuits: int, cycle_depths: Iterable[int]) -> Sequ ) rb_circuit = self._invert_clifford_circuit(base_circuit) irb_circuit = self._invert_clifford_circuit( - self._interleave_gate(base_circuit, self.interleaved_gate, include_final=True) + self._interleave_op( + base_circuit, self.interleaved_gate(*self.qubits), include_final=True + ) ) samples += [ Sample( - circuit=rb_circuit + cirq.measure(sorted(rb_circuit.all_qubits())), + raw_circuit=rb_circuit + cirq.measure(sorted(rb_circuit.all_qubits())), data={ "num_cycles": depth, "circuit_depth": len(rb_circuit), @@ -186,7 +187,7 @@ def build_circuits(self, num_circuits: int, cycle_depths: Iterable[int]) -> Sequ }, ), Sample( - circuit=irb_circuit + cirq.measure(sorted(irb_circuit.all_qubits())), + raw_circuit=irb_circuit + cirq.measure(sorted(irb_circuit.all_qubits())), data={ "num_cycles": depth, "circuit_depth": len(irb_circuit), @@ -197,7 +198,7 @@ def build_circuits(self, num_circuits: int, cycle_depths: Iterable[int]) -> Sequ return samples - def process_probabilities(self, samples: Sequence[Sample]) -> pd.DataFrame: + def _process_probabilities(self, samples: Sequence[Sample]) -> pd.DataFrame: """Processes the probabilities generated by sampling the circuits into the data structures needed for analyzing the results. @@ -237,7 +238,7 @@ def plot_results(self) -> None: ax.set_ylabel(r"Log Circuit fidelity", fontsize=15) ax.set_title(r"Exponential decay of circuit fidelity", fontsize=15) - def analyse_results(self, plot_results: bool = True) -> IRBResults: + def analyze_results(self, plot_results: bool = True) -> IRBResults: """Analyse the experiment results and estimate the interleaved gate error. Args: @@ -249,6 +250,7 @@ def analyse_results(self, plot_results: bool = True) -> IRBResults: self.raw_data["fidelity"] = 2 * self.raw_data["0"] - 1 self.raw_data["log_fidelity"] = np.log(self.raw_data["fidelity"]) + self.raw_data.dropna(axis=0, inplace=True) # Remove any NaNs coming from the P(0) < 0.5 rb_model = linregress( self.raw_data.query("experiment == 'RB'")["clifford_depth"], @@ -266,13 +268,14 @@ def analyse_results(self, plot_results: bool = True) -> IRBResults: irb_layer_fidelity_std = irb_model.stderr * irb_layer_fidelity interleaved_gate_error = (1 - irb_layer_fidelity / rb_layer_fidelity) / 2 - interleaved_gate_error_std = interleaved_gate_error * np.sqrt( - (rb_layer_fidelity_std / rb_layer_fidelity) ** 2 - + (irb_layer_fidelity_std / irb_layer_fidelity) ** 2 + + interleaved_gate_error_std = np.sqrt( + (irb_layer_fidelity_std / (2 * rb_layer_fidelity)) ** 2 + + ((irb_layer_fidelity * rb_layer_fidelity_std) / (2 * rb_layer_fidelity**2)) ** 2 ) self._results = IRBResults( - target="& ".join(self.sample_targets), + target="& ".join(self.targets), total_circuits=len(self.samples), rb_layer_fidelity=rb_layer_fidelity, rb_layer_fidelity_std=rb_layer_fidelity_std, diff --git a/supermarq-benchmarks/supermarq/qcvv/irb_test.py b/supermarq-benchmarks/supermarq/qcvv/irb_test.py index 9a73719bf..0ca170cc5 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb_test.py @@ -84,7 +84,7 @@ def test_irb_process_probabilities(irb_experiment: IRB) -> None: samples = [ Sample( - circuit=cirq.Circuit(), + raw_circuit=cirq.Circuit(), data={ "num_cycles": 20, "circuit_depth": 23, @@ -94,7 +94,7 @@ def test_irb_process_probabilities(irb_experiment: IRB) -> None: ] samples[0].probabilities = {"00": 0.1, "01": 0.2, "10": 0.3, "11": 0.4} - data = irb_experiment.process_probabilities(samples) + data = irb_experiment._process_probabilities(samples) expected_data = pd.DataFrame( [ @@ -124,10 +124,10 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: cirq.ops.SingleQubitCliffordGate.X, ] - circuits = irb_experiment.build_circuits(2, [3]) + circuits = irb_experiment._build_circuits(2, [3]) expected_circuits = [ Sample( - circuit=cirq.Circuit( + raw_circuit=cirq.Circuit( [ cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), @@ -143,14 +143,20 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: }, ), Sample( - circuit=cirq.Circuit( + raw_circuit=cirq.Circuit( [ cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.TaggedOperation( + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile" + ), cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.TaggedOperation( + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile" + ), cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), - cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), - cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), - cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.TaggedOperation( + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile" + ), cirq.ops.SingleQubitCliffordGate.I(*irb_experiment.qubits), cirq.measure(irb_experiment.qubits), ] @@ -162,7 +168,7 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: }, ), Sample( - circuit=cirq.Circuit( + raw_circuit=cirq.Circuit( [ cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), @@ -178,14 +184,20 @@ def test_irb_build_circuit(irb_experiment: IRB) -> None: }, ), Sample( - circuit=cirq.Circuit( + raw_circuit=cirq.Circuit( [ cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), - cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.TaggedOperation( + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile" + ), cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), - cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.TaggedOperation( + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile" + ), cirq.ops.SingleQubitCliffordGate.X(*irb_experiment.qubits), - cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), + cirq.TaggedOperation( + cirq.ops.SingleQubitCliffordGate.Z(*irb_experiment.qubits), "no_compile" + ), cirq.ops.SingleQubitCliffordGate.Y(*irb_experiment.qubits), cirq.measure(irb_experiment.qubits), ] @@ -258,7 +270,7 @@ def test_analyse_results(irb_experiment: IRB) -> None: }, ] ) - irb_experiment.analyse_results() + irb_experiment.analyze_results() assert irb_experiment.results.rb_layer_fidelity == pytest.approx(0.95) assert irb_experiment.results.irb_layer_fidelity == pytest.approx(0.8) From 98303b4ed729b406c99950b44627f0cc407a93f7 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Mon, 19 Aug 2024 14:33:14 +0100 Subject: [PATCH 29/32] Nit: fix formatting --- supermarq-benchmarks/supermarq/qcvv/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/supermarq-benchmarks/supermarq/qcvv/__init__.py b/supermarq-benchmarks/supermarq/qcvv/__init__.py index df1e7e557..15a1c194a 100644 --- a/supermarq-benchmarks/supermarq/qcvv/__init__.py +++ b/supermarq-benchmarks/supermarq/qcvv/__init__.py @@ -4,7 +4,6 @@ from .irb import IRB, IRBResults from .xeb import XEB, XEBResults, XEBSample - __all__ = [ "BenchmarkingExperiment", "BenchmarkingResults", From c3fd26699c6cdbe3c825acd70cf2186b3595602f Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Tue, 27 Aug 2024 10:35:59 +0100 Subject: [PATCH 30/32] Updates following DO review --- .../apps/supermarq/qcvv/qcvv_irb_css.ipynb | 44 +++++++++++++++---- .../supermarq/qcvv/base_experiment.py | 8 ++-- supermarq-benchmarks/supermarq/qcvv/irb.py | 1 + supermarq-benchmarks/supermarq/qcvv/xeb.py | 2 + 4 files changed, 42 insertions(+), 13 deletions(-) diff --git a/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb b/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb index 9cccd5212..0558484fe 100644 --- a/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb +++ b/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb @@ -34,8 +34,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "It is known that an amplitude damping channel with decay probability $\\gamma$ leads to a gate error\n", - "$$\\frac13 + \\frac{\\gamma}{6} - \\frac{\\sqrt{1-\\gamma}}{3}$$" + "We can calculate the average fidelity of this channel [as](https://quantumcomputing.stackexchange.com/questions/16074/how-to-calculate-the-average-fidelity-of-an-amplitude-damping-channel):\n", + "$$\\begin{align}\n", + "\\overline{F} &= \\int\\langle\\psi|\\mathcal{N_\\gamma}(|\\psi\\rangle\\langle\\psi|)|\\psi\\rangle d\\psi\\\\\n", + "&=\\int\\langle\\psi|K_0|\\psi\\rangle\\langle\\psi|K_0^\\dagger|\\psi\\rangle + \\langle\\psi|K_1|\\psi\\rangle\\langle\\psi|K_1^\\dagger|\\psi\\rangle d\\psi\\\\\n", + "& =\\frac{1}{4\\pi}\\int_0^\\pi\\int_0^{2\\pi}\\left|\\begin{pmatrix}\\cos\\frac{\\theta}{2}&e^{-i\\phi}\\sin\\frac{\\theta}{2}\\end{pmatrix}\\begin{pmatrix}1 & 0 \\\\0 & \\sqrt{1 - \\gamma}\\end{pmatrix}\\begin{pmatrix}\\cos\\frac{\\theta}{2}\\\\e^{i\\phi}\\sin\\frac{\\theta}{2}\\end{pmatrix}\\right|^2\\sin\\theta \\\\\n", + "& + \\left|\\begin{pmatrix}\\cos\\frac{\\theta}{2}&e^{-i\\phi}\\sin\\frac{\\theta}{2}\\end{pmatrix}\\begin{pmatrix}0 & \\sqrt{\\gamma} \\\\0 & 0\\end{pmatrix}\\begin{pmatrix}\\cos\\frac{\\theta}{2}\\\\e^{i\\phi}\\sin\\frac{\\theta}{2}\\end{pmatrix}\\right|^2\\sin\\theta d\\phi d\\theta \\\\\n", + "&=\\frac{1}{4\\pi}\\int_0^\\pi\\int_0^{2\\pi}\\left|\\cos^2\\frac{\\theta}{2}+\\sqrt{1-\\gamma}\\sin^2\\frac{\\theta}{2}\\right|^2\\sin\\theta + \\left|\\sqrt{\\gamma}e^{i\\phi}\\sin\\frac{\\theta}{2}\\cos\\frac{\\theta}{2}\\right|^2\\sin\\theta d\\phi d\\theta \\\\\n", + "&=\\frac{1}{2}\\int_0^\\pi\\left(\\cos^4\\frac{\\theta}{2}+(1-\\gamma)\\sin^4\\frac{\\theta}{2}+\\frac{\\sqrt{1-\\gamma}}{2}\\sin^2\\theta + \\frac{\\gamma}{4}\\sin^2\\theta\\right)\\sin\\theta d\\theta \\\\\n", + "&=\\frac{1}{2}\\int_0^\\pi\\sin\\theta\\cos^4\\frac{\\theta}{2}+(1-\\gamma)\\sin\\theta\\sin^4\\frac{\\theta}{2}+\\frac{\\gamma+2\\sqrt{1-\\gamma}}{4}\\sin^3\\theta d\\theta \\\\\n", + "&=\\frac{1}{2}\\left(\\frac{2}{3} + (1-\\gamma)\\frac{2}{3} + \\frac{\\gamma+2\\sqrt{1-\\gamma}}{4}\\frac{4}{3}\\right) \\\\\n", + "&=\\frac{1}{2}\\left(\\frac{4}{3} - \\frac{\\gamma}{3} + \\frac{2\\sqrt{1-\\gamma}}{3}\\right) \\\\\n", + "&=\\frac{2}{3}-\\frac{\\gamma}{6} + \\frac{\\sqrt{1-\\gamma}}{3}.\n", + "\\end{align}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Thus we have a gate error $$\\frac{1}{3}+\\frac{\\gamma}{6} - \\frac{\\sqrt{1-\\gamma}}{3}$$" ] }, { @@ -55,7 +73,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d55fb24f5d6843b2baa312983100e4ec", + "model_id": "a89059d2c1f34a19bb332786290649c6", "version_major": 2, "version_minor": 0 }, @@ -69,7 +87,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cd79c53df3014fe1a282b27944f27d2e", + "model_id": "7a66c540ec1c43cca169dd3fa6b5e8c3", "version_major": 2, "version_minor": 0 }, @@ -82,9 +100,9 @@ } ], "source": [ - "from supermarq.qcvv import IRB\n", + "import supermarq\n", "\n", - "experiment = IRB()\n", + "experiment = supermarq.qcvv.IRB()\n", "experiment.prepare_experiment(100, [1, 5, 10, 15])\n", "experiment.run_with_simulator(simulator=simulator)" ] @@ -94,16 +112,24 @@ "execution_count": 4, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/cdb/miniconda3/envs/client_superstaq/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "IRBResults(target='Local simulator', total_circuits=800, experiment_name='IRB', rb_layer_fidelity=0.9671846265179108, rb_layer_fidelity_std=0.000987097677514484, irb_layer_fidelity=0.937823622414394, irb_layer_fidelity_std=0.0023115403435816856, average_interleaved_gate_error=0.015178593258467765, average_interleaved_gate_error_std=0.001293374288000066)\n" + "IRBResults(target='Local simulator', total_circuits=800, experiment_name='IRB', rb_layer_fidelity=0.967400880362247, rb_layer_fidelity_std=0.0009381203019248942, irb_layer_fidelity=0.9365570504829388, irb_layer_fidelity_std=0.0024157723898343662, average_interleaved_gate_error=0.015941596966377924, average_interleaved_gate_error_std=0.0013339107674075268)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -128,7 +154,7 @@ "output_type": "stream", "text": [ "Expected gate error: 0.016774\n", - "Measured gate error: 0.015179 +/- 0.001293\n" + "Measured gate error: 0.015942 +/- 0.001334\n" ] } ], diff --git a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py index 3d7edd2fd..a812ab25a 100644 --- a/supermarq-benchmarks/supermarq/qcvv/base_experiment.py +++ b/supermarq-benchmarks/supermarq/qcvv/base_experiment.py @@ -345,7 +345,7 @@ def _retrieve_jobs(self) -> dict[str, str]: return statuses - def _run_check(self) -> None: + def _has_raw_data(self) -> None: """Checks if any of the samples already have probabilities stored. If so raises a runtime error to prevent them from being overwritten. @@ -523,7 +523,7 @@ def run_on_device( The superstaq job containing all the circuits submitted as part of the experiment. """ if not overwrite: - self._run_check() + self._has_raw_data() experiment_job = self._service.create_job( [sample.circuit for sample in self.samples], @@ -556,7 +556,7 @@ def run_with_simulator( be over written in the process. Defaults to False. """ if not overwrite: - self._run_check() + self._has_raw_data() if simulator is None: simulator = cirq.Simulator() @@ -593,7 +593,7 @@ def run_with_callable( RuntimeError: If the returned probabilities dictionary values do not sum to 1.0. """ if not overwrite: - self._run_check() + self._has_raw_data() for sample in tqdm(self.samples, desc="Running circuits"): probability = circuit_eval_func(sample.circuit, **kwargs) if not all(len(key) == self.num_qubits for key in probability.keys()): diff --git a/supermarq-benchmarks/supermarq/qcvv/irb.py b/supermarq-benchmarks/supermarq/qcvv/irb.py index 6d3d9ea52..9c12e057a 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb.py @@ -77,6 +77,7 @@ class IRB(BenchmarkingExperiment[IRBResults]): e_{\mathcal{C}^*} = \frac{1}{2} \left(1 - \frac{\tilde{\alpha}}{\alpha}\right) + For more details see: https://arxiv.org/abs/1203.4550 """ def __init__( diff --git a/supermarq-benchmarks/supermarq/qcvv/xeb.py b/supermarq-benchmarks/supermarq/qcvv/xeb.py index f3c2a5ddb..dfc23d29e 100644 --- a/supermarq-benchmarks/supermarq/qcvv/xeb.py +++ b/supermarq-benchmarks/supermarq/qcvv/xeb.py @@ -117,6 +117,8 @@ class XEB(BenchmarkingExperiment[XEBResults]): Thus fitting another linear model to :math:`\log(f_d) \sim d` provides us with an estimate of the cycle fidelity. + + For more details see: https://www.nature.com/articles/s41586-019-1666-5 """ def __init__( From 8e5af5538ea8cde60c2bbec7cea720bf71f36e71 Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 6 Sep 2024 09:17:59 +0100 Subject: [PATCH 31/32] Changes following DO review --- .../apps/supermarq/qcvv/qcvv_irb_css.ipynb | 46 +++++++++---------- supermarq-benchmarks/supermarq/qcvv/irb.py | 20 ++++---- .../supermarq/qcvv/irb_test.py | 1 - 3 files changed, 33 insertions(+), 34 deletions(-) diff --git a/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb b/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb index 0558484fe..086f57a83 100644 --- a/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb +++ b/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb @@ -24,8 +24,16 @@ "source": [ "import cirq\n", "import numpy as np\n", - "\n", - "decay_prob = 0.05\n", + "import supermarq" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "decay_prob = 0.025\n", "noise = cirq.AmplitudeDampingChannel(gamma=decay_prob)\n", "simulator = cirq.DensityMatrixSimulator(noise=noise)" ] @@ -58,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -67,13 +75,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a89059d2c1f34a19bb332786290649c6", + "model_id": "3707426ff75d42b18b4f7329a12bd870", "version_major": 2, "version_minor": 0 }, @@ -87,7 +95,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7a66c540ec1c43cca169dd3fa6b5e8c3", + "model_id": "3f98bdcc70504c759ea0583c79dab7c9", "version_major": 2, "version_minor": 0 }, @@ -100,36 +108,28 @@ } ], "source": [ - "import supermarq\n", - "\n", - "experiment = supermarq.qcvv.IRB()\n", + "experiment = supermarq.qcvv.IRB(\n", + " interleaved_gate=cirq.ops.SingleQubitCliffordGate.Y\n", + ")\n", "experiment.prepare_experiment(100, [1, 5, 10, 15])\n", "experiment.run_with_simulator(simulator=simulator)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/cdb/miniconda3/envs/client_superstaq/lib/python3.11/site-packages/pandas/core/arraylike.py:399: RuntimeWarning: invalid value encountered in log\n", - " result = getattr(ufunc, method)(*inputs, **kwargs)\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "IRBResults(target='Local simulator', total_circuits=800, experiment_name='IRB', rb_layer_fidelity=0.967400880362247, rb_layer_fidelity_std=0.0009381203019248942, irb_layer_fidelity=0.9365570504829388, irb_layer_fidelity_std=0.0024157723898343662, average_interleaved_gate_error=0.015941596966377924, average_interleaved_gate_error_std=0.0013339107674075268)\n" + "IRBResults(target='Local simulator', total_circuits=800, experiment_name='IRB', rb_layer_fidelity=0.9835345476930657, rb_layer_fidelity_std=0.0004865849120610916, irb_layer_fidelity=0.9672464523458026, irb_layer_fidelity_std=0.000336442324359281, average_interleaved_gate_error=0.008280388007451123, average_interleaved_gate_error_std=0.0002973777530802783)\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -146,15 +146,15 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Expected gate error: 0.016774\n", - "Measured gate error: 0.015942 +/- 0.001334\n" + "Expected gate error: 0.008360\n", + "Measured gate error: 0.008280 +/- 0.000297\n" ] } ], diff --git a/supermarq-benchmarks/supermarq/qcvv/irb.py b/supermarq-benchmarks/supermarq/qcvv/irb.py index 9c12e057a..dbd8824c3 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb.py @@ -68,7 +68,7 @@ class IRB(BenchmarkingExperiment[IRBResults]): f(m) = 2p(0...0) - 1 - We can then fit and exponential decay :math:`\log(f) \sim m` to this circuit fidelity + We can then fit an exponential decay :math:`\log(f) \sim m` to this circuit fidelity for each circuit, with decay rates :math:`\alpha` and :math:`\tilde{\alpha}` for the circuit without and with interleaving respectively. Finally the gate error of the specified gate, :math:`\mathcal{C}^*` is estimated as @@ -85,9 +85,11 @@ def __init__( interleaved_gate: cirq.ops.SingleQubitCliffordGate = cirq.ops.SingleQubitCliffordGate.Z, num_qubits: int = 1, ) -> None: - """Args: - interleaved_gate: The Clifford gate to measure the gate error of. - num_qubits: The number of qubits to experiment on + """Constructs an IRB experiment. + + Args: + interleaved_gate: The single qubit Clifford gate to measure the gate error of. + num_qubits: The number of qubits to experiment on """ if num_qubits != 1: raise NotImplementedError( @@ -106,7 +108,7 @@ def _reduce_clifford_seq( Args: gate_seq: The list of gates. - + The single reduced gate. Returns: The single reduced gate """ @@ -117,7 +119,7 @@ def _reduce_clifford_seq( @classmethod def _random_single_qubit_clifford(cls) -> cirq.ops.SingleQubitCliffordGate: - """Choose a random singe qubit clifford gate. + """Choose a random single qubit clifford gate. Returns: The random clifford gate. @@ -143,7 +145,7 @@ def _random_single_qubit_clifford(cls) -> cirq.ops.SingleQubitCliffordGate: return cls._reduce_clifford_seq([random.choice(set_A), random.choice(set_B)]) def _invert_clifford_circuit(self, circuit: cirq.Circuit) -> cirq.Circuit: - """Given a Clifford circuit find and append the corresponding inverse Clifford gate + """Given a Clifford circuit find and append the corresponding inverse Clifford gate. Args: circuit: The Clifford circuit to invert. @@ -224,9 +226,7 @@ def _process_probabilities(self, samples: Sequence[Sample]) -> pd.DataFrame: return pd.DataFrame(records) def plot_results(self) -> None: - """Plot the exponential decay of the circuit fidelity with - cycle depth. - """ + """Plot the exponential decay of the circuit fidelity with cycle depth.""" plot = sns.lmplot( data=self.raw_data, x="clifford_depth", diff --git a/supermarq-benchmarks/supermarq/qcvv/irb_test.py b/supermarq-benchmarks/supermarq/qcvv/irb_test.py index 0ca170cc5..0106dc11c 100644 --- a/supermarq-benchmarks/supermarq/qcvv/irb_test.py +++ b/supermarq-benchmarks/supermarq/qcvv/irb_test.py @@ -81,7 +81,6 @@ def test_invert_clifford_circuit(irb_experiment: IRB) -> None: def test_irb_process_probabilities(irb_experiment: IRB) -> None: - samples = [ Sample( raw_circuit=cirq.Circuit(), From 3a37d139ec99865a306aef8a47b5172cd37f8d5d Mon Sep 17 00:00:00 2001 From: Cameron Booker Date: Fri, 6 Sep 2024 09:29:47 +0100 Subject: [PATCH 32/32] Nit: formatting --- docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb b/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb index 086f57a83..793bf499c 100644 --- a/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb +++ b/docs/source/apps/supermarq/qcvv/qcvv_irb_css.ipynb @@ -108,9 +108,7 @@ } ], "source": [ - "experiment = supermarq.qcvv.IRB(\n", - " interleaved_gate=cirq.ops.SingleQubitCliffordGate.Y\n", - ")\n", + "experiment = supermarq.qcvv.IRB(interleaved_gate=cirq.ops.SingleQubitCliffordGate.Y)\n", "experiment.prepare_experiment(100, [1, 5, 10, 15])\n", "experiment.run_with_simulator(simulator=simulator)" ]