From ca4e612a2c166c60f0e06c61b236653fe7276b01 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Wed, 20 Oct 2021 20:45:16 +0200 Subject: [PATCH 01/19] * Added specializations. * Moved fine amp to characterization. * Refactored some tests. --- .../calibration_management/__init__.py | 1 + .../calibration_management/update_library.py | 21 +- qiskit_experiments/library/__init__.py | 9 +- .../library/calibration/__init__.py | 8 +- .../library/calibration/fine_amplitude.py | 329 ++++-------------- .../library/characterization/__init__.py | 4 + .../characterization/fine_amplitude.py | 303 ++++++++++++++++ .../experiments/test_fine_amplitude.py | 96 ++--- 8 files changed, 434 insertions(+), 337 deletions(-) create mode 100644 qiskit_experiments/library/characterization/fine_amplitude.py diff --git a/qiskit_experiments/calibration_management/__init__.py b/qiskit_experiments/calibration_management/__init__.py index aa3d4ab3ad..6a41faeb59 100644 --- a/qiskit_experiments/calibration_management/__init__.py +++ b/qiskit_experiments/calibration_management/__init__.py @@ -148,5 +148,6 @@ from .calibrations import Calibrations from .backend_calibrations import BackendCalibrations +from .base_calibration_experiment import BaseCalibrationExperiment from .update_library import Frequency, Drag, Amplitude, FineDragUpdater diff --git a/qiskit_experiments/calibration_management/update_library.py b/qiskit_experiments/calibration_management/update_library.py index 8c0a932bf2..57a177aba8 100644 --- a/qiskit_experiments/calibration_management/update_library.py +++ b/qiskit_experiments/calibration_management/update_library.py @@ -60,7 +60,7 @@ def _time_stamp(exp_data: ExperimentData) -> datetime: return datetime.now(timezone.utc).astimezone() @classmethod - def _add_parameter_value( + def add_parameter_value( cls, cal: Calibrations, exp_data: ExperimentData, @@ -123,7 +123,7 @@ def update( fit_parameter = fit_parameter or cls.__fit_parameter__ value = BaseUpdater.get_value(exp_data, fit_parameter, result_index) - cls._add_parameter_value( + cls.add_parameter_value( calibrations, exp_data, value, parameter, schedule=schedule, group=group ) @@ -244,7 +244,7 @@ def update( old_beta = calibrations.get_parameter_value(parameter, qubits, schedule, group=group) new_beta = old_beta + d_beta - cls._add_parameter_value(calibrations, exp_data, new_beta, parameter, schedule, group) + cls.add_parameter_value(calibrations, exp_data, new_beta, parameter, schedule, group) class Amplitude(BaseUpdater): @@ -281,7 +281,6 @@ def update( CalibrationError: If the experiment is not of the supported type. """ from qiskit_experiments.library.calibration.rabi import Rabi - from qiskit_experiments.library.calibration.fine_amplitude import FineAmplitude if angles_schedules is None: angles_schedules = [(np.pi, "amp", "xp")] @@ -295,19 +294,7 @@ def update( value = np.round(angle / rate, decimals=8) * np.exp(1.0j * np.angle(prev_amp)) - cls._add_parameter_value(calibrations, exp_data, value, param, schedule, group) - - elif isinstance(exp_data.experiment, FineAmplitude): - d_theta = BaseUpdater.get_value(exp_data, "d_theta", result_index) - - for target_angle, param, schedule in angles_schedules: - qubits = exp_data.metadata["physical_qubits"] - - prev_amp = calibrations.get_parameter_value(param, qubits, schedule, group=group) - scale = target_angle / (target_angle + d_theta) - new_amp = prev_amp * scale - - cls._add_parameter_value(calibrations, exp_data, new_amp, param, schedule, group) + cls.add_parameter_value(calibrations, exp_data, value, param, schedule, group) else: raise CalibrationError(f"{cls.__name__} updates from {type(Rabi.__name__)}.") diff --git a/qiskit_experiments/library/__init__.py b/qiskit_experiments/library/__init__.py index 1f2c7cb5fc..6e85582bcb 100644 --- a/qiskit_experiments/library/__init__.py +++ b/qiskit_experiments/library/__init__.py @@ -98,9 +98,9 @@ class instance to manage parameters and pulse schedules. FineSXDrag, Rabi, EFRabi, - FineAmplitude, - FineXAmplitude, - FineSXAmplitude, + FineAmplitudeCal, + FineXAmplitudeCal, + FineSXAmplitudeCal, RoughFrequencyCal, RamseyXY, ) @@ -111,6 +111,9 @@ class instance to manage parameters and pulse schedules. EFSpectroscopy, CrossResonanceHamiltonian, EchoedCrossResonanceHamiltonian, + FineAmplitude, + FineXAmplitude, + FineSXAmplitude, ) from .randomized_benchmarking import StandardRB, InterleavedRB from .tomography import StateTomography, ProcessTomography diff --git a/qiskit_experiments/library/calibration/__init__.py b/qiskit_experiments/library/calibration/__init__.py index 2e8292a8b3..139c575207 100644 --- a/qiskit_experiments/library/calibration/__init__.py +++ b/qiskit_experiments/library/calibration/__init__.py @@ -45,9 +45,9 @@ FineXDrag FineSXDrag Rabi - FineAmplitude - FineXAmplitude - FineSXAmplitude + FineAmplitudeCal + FineXAmplitudeCal + FineSXAmplitudeCal RamseyXY Calibration analysis @@ -70,8 +70,8 @@ from .rough_frequency import RoughFrequencyCal from .drag import DragCal from .fine_drag import FineDrag, FineXDrag, FineSXDrag +from .fine_amplitude import FineAmplitudeCal, FineXAmplitudeCal, FineSXAmplitudeCal from .rabi import Rabi, EFRabi -from .fine_amplitude import FineAmplitude, FineXAmplitude, FineSXAmplitude from .ramsey_xy import RamseyXY from .analysis.drag_analysis import DragCalAnalysis diff --git a/qiskit_experiments/library/calibration/fine_amplitude.py b/qiskit_experiments/library/calibration/fine_amplitude.py index a96413aecd..0c3094870b 100644 --- a/qiskit_experiments/library/calibration/fine_amplitude.py +++ b/qiskit_experiments/library/calibration/fine_amplitude.py @@ -12,284 +12,117 @@ """Fine amplitude calibration experiment.""" -from typing import List, Optional +from typing import Optional import numpy as np -from qiskit import QuantumCircuit from qiskit.circuit import Gate -from qiskit.circuit.library import XGate, SXGate -from qiskit.providers import Backend -from qiskit.pulse.schedule import ScheduleBlock -from qiskit_experiments.framework import BaseExperiment, Options -from qiskit_experiments.library.calibration.analysis.fine_amplitude_analysis import ( - FineAmplitudeAnalysis, +from qiskit_experiments.calibration_management import ( + BaseCalibrationExperiment, + BackendCalibrations, ) -from qiskit_experiments.exceptions import CalibrationError +from qiskit_experiments.library.characterization import FineAmplitude +from qiskit_experiments.framework import ExperimentData, Options +from qiskit_experiments.calibration_management.update_library import BaseUpdater -class FineAmplitude(BaseExperiment): - r"""Error amplifying fine amplitude calibration experiment. +class FineAmplitudeCal(BaseCalibrationExperiment, FineAmplitude): + """A calibration version of the fine amplitude experiment.""" - # section: overview - - The :class:`FineAmplitude` calibration experiment repeats N times a gate with a pulse - to amplify the under-/over-rotations in the gate to determine the optimal amplitude. - The circuits that are run have a custom gate with the pulse schedule attached to it - through the calibrations. The circuits are therefore of the form: - - .. parsed-literal:: - - ┌─────┐ ┌─────┐ ░ ┌─┐ - q_0: ┤ Cal ├─ ... ─┤ Cal ├─░─┤M├ - └─────┘ └─────┘ ░ └╥┘ - measure: 1/════════ ... ════════════╩═ - 0 - - Here, Cal is the name of the gate which will be taken from the name of the schedule. - The user can optionally add a square-root of X pulse before the Cal gates are repeated. - This square-root of X pulse allows the analysis to differentiate between over rotations - and under rotations in the case of pi-pulses. Importantly, the resulting data is analyzed - by a fit to a cosine function in which we try and determine the over/under rotation given - an intended rotation angle per gate which must also be specified by the user. - - Error amplifying experiments are most sensitive to angle errors when we measure points along - the equator of the Block sphere. This is why users should insert a square-root of X pulse - before running calibrations for :math:`\pm\pi` rotations. Furthermore, when running - calibrations for :math:`\pm\pi/2` rotations users are advised to use an odd number of - repetitions, e.g. [1, 2, 3, 5, 7, ...] to ensure that the ideal points are on the equator - of the Bloch sphere. Note the presence of two repetitions which allows us to prepare the - excited state. Therefore, add_xp_circuit = True is not needed in this case. - - Users can call :meth:`set_schedule` to conveniently set the schedule and the corresponding - experiment and analysis options. - - # section: example - - - The steps to run a fine amplitude calibration experiment are - - .. code-block:: python - - qubit = 3 - amp_cal = FineAmplitude(qubit) - amp_cal.set_schedule( - schedule=x90p, - angle_per_gate=np.pi/2, - add_xp_circuit=False, - add_sx=False - ) - amp_cal.run(backend) - - Note that the ``schedule`` and ``angle_per_gate`` could have been set by independently calling - :meth:`set_experiment_options` for the ``schedule`` and :meth:`set_analysis_options` for - the ``angle_per_gate``. - - - # section: reference - .. ref_arxiv:: 1 1504.06597 - - - # section: tutorial - :doc:`/tutorials/fine_calibrations` - - """ - - __analysis_class__ = FineAmplitudeAnalysis - - @classmethod - def _default_experiment_options(cls) -> Options: - r"""Default values for the fine amplitude experiment. - - Experiment Options: - repetitions (List[int]): A list of the number of times that the gate is repeated. - schedule (ScheduleBlock): The schedule attached to the gate that will be repeated. - gate_type (Type): This is a gate class such as XGate, so that one can obtain a gate - by doing :code:`options.gate_class()`. - normalization (bool): If set to True the DataProcessor will normalized the - measured signal to the interval [0, 1]. Defaults to True. - add_sx (bool): If True then the circuits will start with an sx gate. This is typically - needed when calibrating pulses with a target rotation angle of :math:`\pi`. The - default value is False. - add_xp_circuit (bool): If set to True then a circuit with only an X gate will also be - run. This allows the analysis class to determine the correct sign for the amplitude. - sx_schedule (ScheduleBlock): The schedule to attache to the SX gate. - """ - options = super()._default_experiment_options() - options.repetitions = list(range(15)) - options.schedule = None - options.gate_type = None - options.normalization = True - options.add_sx = False - options.add_xp_circuit = True - options.sx_schedule = None - - return options - - def __init__(self, qubit: int): - """Setup a fine amplitude experiment on the given qubit. - - Args: - qubit: The qubit on which to run the fine amplitude calibration experiment. - """ - super().__init__([qubit]) - - def set_schedule( + def __init__( self, - schedule: ScheduleBlock, - angle_per_gate: float, - add_xp_circuit: bool, - add_sx: bool, + qubit: int, + calibrations: BackendCalibrations, + schedule_name: str, + cal_parameter_name: Optional[str] = "amp", + auto_update: bool = True, ): - r"""Set the schedule and its corresponding intended angle per gate. + """see class :class:`FineAmplitude` for details. Args: - schedule: The schedule to attache to the gates. - angle_per_gate: The intended angle per gate used by the analysis method. - add_xp_circuit: If True then a circuit preparing the excited state is also run. - add_sx: Whether or not to add a pi-half pulse before running the calibration. + qubit: The qubit for which to run the fine amplitude calibration. + calibrations: The calibrations instance with the schedules. + schedule_name: The name of the schedule to calibrate. + cal_parameter_name: The name of the parameter in the schedule to update. + auto_update: Weather or not to automatically update the calibrations. By + default this variable is set to True. - Raises: - CalibrationError: If the target angle is a multiple of :math:`2\pi`. """ - self.set_experiment_options(schedule=schedule, add_xp_circuit=add_xp_circuit, add_sx=add_sx) + super().__init__( + calibrations, + qubit, + Gate(name=schedule_name, num_qubits=1, params=[]), + schedule_name=schedule_name, + cal_parameter_name=cal_parameter_name, + auto_update=auto_update + ) - if np.isclose(angle_per_gate % (2 * np.pi), 0.0): - raise CalibrationError( - f"It does not make sense to use {self.__class__.__name__} on a pulse with an " - "angle_per_gate of zero as the update rule will set the amplitude to zero " - "angle_per_gate / (angle_per_gate + d_theta)." - ) + self.transpile_options.inst_map = calibrations.default_inst_map - phase_offset = np.pi / 2 if add_sx else 0 - - self.set_analysis_options(angle_per_gate=angle_per_gate, phase_offset=phase_offset) - - def _pre_circuit(self) -> QuantumCircuit: - """Return a preparation circuit. - - This method can be overridden by subclasses e.g. to calibrate schedules on - transitions other than the 0 <-> 1 transition. - """ - circuit = QuantumCircuit(1) + def _default_experiment_options(cls): + """Default values for the fine amplitude calibration experiment. - if self.experiment_options.add_sx: - circuit.sx(0) - - if self.experiment_options.sx_schedule is not None: - sx_schedule = self.experiment_options.sx_schedule - circuit.add_calibration("sx", (self.physical_qubits[0],), sx_schedule, params=[]) - circuit.barrier() - - return circuit - - def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: - """Create the circuits for the fine amplitude calibration experiment. - - Args: - backend: A backend object. - - Returns: - A list of circuits with a variable number of gates. Each gate has the same - pulse schedule. + Experiment Options: + result_index (int): The index of the result from which to update the calibrations. + target_angle (float): The target angle of the pulse. + group (str): The calibration group to which the parameter belongs. This will default + to the value "default". - Raises: - CalibrationError: If no schedule was provided. - CalibrationError: If the channel index does not correspond to the physical qubit index. - CalibrationError: If the schedule contains unassigned parameters. - CalibrationError: If the analysis options do not contain the angle_per_gate. """ + options = super()._default_transpile_options() - # Get the schedule and check assumptions. - schedule = self.experiment_options.schedule + options.result_index = -1 + options.target_angle = np.pi + options.group = "default" - if schedule is None: - gate = self.experiment_options.gate_type() - else: - gate = Gate(name=schedule.name, num_qubits=1, params=[]) - - if self.physical_qubits[0] not in set(ch.index for ch in schedule.channels): - raise CalibrationError( - f"User provided schedule {schedule.name} does not contain a channel " - "for the qubit on which to run the fine amplitude calibration." - ) - - if len(schedule.parameters) > 0: - raise CalibrationError( - "All parameters in a fine amplitude calibration schedule must be bound. " - f"Unbound parameters: {schedule.parameters}" - ) - - # Prepare the circuits. - repetitions = self.experiment_options.get("repetitions") - - circuits = [] - - if self.experiment_options.add_xp_circuit: - # Note that the rotation error in this xval will be overweighted when calibrating xp - # because it will be treated as a half pulse instead of a full pulse. However, since - # the qubit population is first-order insensitive to rotation errors for an xp pulse - # this point won't contribute much to inferring the angle error. - angle_per_gate = self.analysis_options.get("angle_per_gate", None) - phase_offset = self.analysis_options.get("phase_offset") - - if angle_per_gate is None: - raise CalibrationError( - f"Unknown angle_per_gate for {self.__class__.__name__}. " - "Please set it in the analysis options." - ) - - circuit = QuantumCircuit(1) - circuit.x(0) - circuit.measure_all() - - circuit.metadata = { - "experiment_type": self._type, - "qubits": self.physical_qubits, - "xval": (np.pi - phase_offset) / angle_per_gate, - "unit": "gate number", - } - - circuits.append(circuit) + return options - for repetition in repetitions: - circuit = self._pre_circuit() + def update_calibrations(self, experiment_data: ExperimentData): + """Update the amplitude of the pulse in the calibrations. - for _ in range(repetition): - circuit.append(gate, (0,)) + The update rule of this experiment is - circuit.measure_all() + .. math:: - if schedule is not None: - circuit.add_calibration(gate, self.physical_qubits, schedule, params=[]) + A \to A \frac{\theta_\text{target}}{\theta_\text{target} + {\rm d}\theta} - circuit.metadata = { - "experiment_type": self._type, - "qubits": self.physical_qubits, - "xval": repetition, - "unit": "gate number", - } + Where :math:`A` is the amplitude of the pulse before the update. - circuits.append(circuit) + Args: + experiment_data: The experiment data from which to extract the measured over/under + rotation used to adjust the amplitude. + """ + result_index = self.experiment_options.result_index + group = self.experiment_options.group + target_angle = self.experiment_options.target_angle - return circuits + d_theta = BaseUpdater.get_value(experiment_data, "d_theta", result_index) + prev_amp = self._cals.get_parameter_value( + self._param_name, + experiment_data.metadata["physical_qubits"], + self._sched_name, + group=group + ) -class FineXAmplitude(FineAmplitude): - r"""A fine amplitude experiment with all the options set for the :math:`\pi`-rotation. + BaseUpdater.add_parameter_value( + self._cals, + experiment_data, + prev_amp * target_angle / (target_angle + d_theta), + self._param_name, + self._sched_name, + group + ) - # section: overview - :class:`FineXAmplitude` is a subclass of :class:`FineAmplitude` and is used to set - the appropriate values for the default options. - """ +class FineXAmplitudeCal(FineAmplitudeCal): + """A calibration experiment to calibrate the amplitude of the X schedule.""" @classmethod def _default_experiment_options(cls) -> Options: r"""Default values for the fine amplitude experiment. Experiment Options: - gate_type (Type): FineXAmplitude calibrates an XGate. add_sx (bool): This option is True by default when calibrating gates with a target angle per gate of :math:`\pi` as this increases the sensitivity of the experiment. @@ -297,7 +130,6 @@ def _default_experiment_options(cls) -> Options: a target angle per gate of :math:`\pi`. """ options = super()._default_experiment_options() - options.gate_type = XGate options.add_sx = True options.add_xp_circuit = True @@ -313,21 +145,14 @@ def _default_analysis_options(cls) -> Options: return options -class FineSXAmplitude(FineAmplitude): - r"""A fine amplitude experiment with all the options set for the :math:`\pi/2`-rotation. - - # section: overview - - :class:`FineSXAmplitude` is a subclass of :class:`FineAmplitude` and is used to set - the appropriate values for the default options. - """ +class FineSXAmplitudeCal(FineAmplitudeCal): + """A calibration experiment to calibrate the amplitude of the SX schedule.""" @classmethod def _default_experiment_options(cls) -> Options: r"""Default values for the fine amplitude experiment. Experiment Options: - gate_type (Type): FineSXAmplitude calibrates an SXGate. add_sx (bool): This option is False by default when calibrating gates with a target angle per gate of :math:`\pi/2` as this increases the sensitivity of the experiment. @@ -337,13 +162,13 @@ def _default_experiment_options(cls) -> Options: :math:`\pi/2` target angles as this ideally prepares states on the equator of the Bloch sphere. Note that the repetitions include two repetitions which plays the same role as including a circuit with an X gate. + target_angle (float): The target angle per gate. """ options = super()._default_experiment_options() - options.gate_type = SXGate options.add_sx = False options.add_xp_circuit = False options.repetitions = [1, 2, 3, 5, 7, 9, 11, 13, 15, 17, 21, 23, 25] - + options.target_angle = np.pi / 2 return options @classmethod diff --git a/qiskit_experiments/library/characterization/__init__.py b/qiskit_experiments/library/characterization/__init__.py index a3a9cc1cf8..25e2f473d9 100644 --- a/qiskit_experiments/library/characterization/__init__.py +++ b/qiskit_experiments/library/characterization/__init__.py @@ -28,6 +28,9 @@ QubitSpectroscopy CrossResonanceHamiltonian EchoedCrossResonanceHamiltonian + FineAmplitude + FineXAmplitude + FineSXAmplitude Analysis @@ -51,3 +54,4 @@ from .t2ramsey_analysis import T2RamseyAnalysis from .cr_hamiltonian import CrossResonanceHamiltonian, EchoedCrossResonanceHamiltonian from .cr_hamiltonian_analysis import CrossResonanceHamiltonianAnalysis +from .fine_amplitude import FineAmplitude, FineXAmplitude, FineSXAmplitude diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py new file mode 100644 index 0000000000..1a68f953b4 --- /dev/null +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -0,0 +1,303 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2021. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Fine amplitude characterization experiment.""" + +from typing import List, Optional +import numpy as np + +from qiskit import QuantumCircuit +from qiskit.circuit import Gate +from qiskit.circuit.library import XGate, SXGate +from qiskit.providers import Backend + +from qiskit_experiments.framework import BaseExperiment, Options +from qiskit_experiments.library.calibration.analysis.fine_amplitude_analysis import ( + FineAmplitudeAnalysis, +) +from qiskit_experiments.exceptions import CalibrationError + + +class FineAmplitude(BaseExperiment): + r"""Error amplifying fine amplitude calibration experiment. + + # section: overview + + The :class:`FineAmplitude` calibration experiment repeats N times a gate with a pulse + to amplify the under-/over-rotations in the gate to determine the optimal amplitude. + The circuits that are run have a custom gate with the pulse schedule attached to it + through the calibrations. The circuits are therefore of the form: + + .. parsed-literal:: + + ┌─────┐ ┌─────┐ ░ ┌─┐ + q_0: ┤ Cal ├─ ... ─┤ Cal ├─░─┤M├ + └─────┘ └─────┘ ░ └╥┘ + measure: 1/════════ ... ════════════╩═ + 0 + + Here, Cal is the name of the gate which will be taken from the name of the schedule. + The user can optionally add a square-root of X pulse before the Cal gates are repeated. + This square-root of X pulse allows the analysis to differentiate between over rotations + and under rotations in the case of pi-pulses. Importantly, the resulting data is analyzed + by a fit to a cosine function in which we try and determine the over/under rotation given + an intended rotation angle per gate which must also be specified by the user. + + Error amplifying experiments are most sensitive to angle errors when we measure points along + the equator of the Block sphere. This is why users should insert a square-root of X pulse + before running calibrations for :math:`\pm\pi` rotations. Furthermore, when running + calibrations for :math:`\pm\pi/2` rotations users are advised to use an odd number of + repetitions, e.g. [1, 2, 3, 5, 7, ...] to ensure that the ideal points are on the equator + of the Bloch sphere. Note the presence of two repetitions which allows us to prepare the + excited state. Therefore, add_xp_circuit = True is not needed in this case. + + Users can call :meth:`set_schedule` to conveniently set the schedule and the corresponding + experiment and analysis options. + + # section: example + + + The steps to run a fine amplitude calibration experiment are + + .. code-block:: python + + qubit = 3 + amp_cal = FineAmplitude(qubit) + amp_cal.set_schedule( + schedule=x90p, + angle_per_gate=np.pi/2, + add_xp_circuit=False, + add_sx=False + ) + amp_cal.run(backend) + + Note that the ``schedule`` and ``angle_per_gate`` could have been set by independently calling + :meth:`set_experiment_options` for the ``schedule`` and :meth:`set_analysis_options` for + the ``angle_per_gate``. + + + # section: reference + .. ref_arxiv:: 1 1504.06597 + + + # section: tutorial + :doc:`/tutorials/fine_calibrations` + + """ + + __analysis_class__ = FineAmplitudeAnalysis + + @classmethod + def _default_experiment_options(cls) -> Options: + r"""Default values for the fine amplitude experiment. + + Experiment Options: + repetitions (List[int]): A list of the number of times that the gate is repeated. + schedule (ScheduleBlock): The schedule attached to the gate that will be repeated. + gate_type (Type): This is a gate class such as XGate, so that one can obtain a gate + by doing :code:`options.gate_class()`. + normalization (bool): If set to True the DataProcessor will normalized the + measured signal to the interval [0, 1]. Defaults to True. + add_sx (bool): If True then the circuits will start with an sx gate. This is typically + needed when calibrating pulses with a target rotation angle of :math:`\pi`. The + default value is False. + add_xp_circuit (bool): If set to True then a circuit with only an X gate will also be + run. This allows the analysis class to determine the correct sign for the amplitude. + sx_schedule (ScheduleBlock): The schedule to attache to the SX gate. + """ + options = super()._default_experiment_options() + options.repetitions = list(range(15)) + options.gate = None + options.normalization = True + options.add_sx = False + options.add_xp_circuit = True + + return options + + def __init__(self, qubit: int, gate: Gate): + """Setup a fine amplitude experiment on the given qubit. + + Args: + qubit: The qubit on which to run the fine amplitude calibration experiment. + gate: The gate that will be repeated. + """ + super().__init__([qubit]) + self.experiment_options.gate = gate + + def _pre_circuit(self) -> QuantumCircuit: + """Return a preparation circuit. + + This method can be overridden by subclasses e.g. to calibrate schedules on + transitions other than the 0 <-> 1 transition. + """ + circuit = QuantumCircuit(1) + + if self.experiment_options.add_sx: + circuit.sx(0) + + return circuit + + def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: + """Create the circuits for the fine amplitude calibration experiment. + + Args: + backend: A backend object. + + Returns: + A list of circuits with a variable number of gates. Each gate has the same + pulse schedule. + + Raises: + CalibrationError: If no schedule was provided. + CalibrationError: If the channel index does not correspond to the physical qubit index. + CalibrationError: If the schedule contains unassigned parameters. + CalibrationError: If the analysis options do not contain the angle_per_gate. + """ + # Prepare the circuits. + repetitions = self.experiment_options.get("repetitions") + + circuits = [] + + if self.experiment_options.add_xp_circuit: + # Note that the rotation error in this xval will be overweighted when calibrating xp + # because it will be treated as a half pulse instead of a full pulse. However, since + # the qubit population is first-order insensitive to rotation errors for an xp pulse + # this point won't contribute much to inferring the angle error. + angle_per_gate = self.analysis_options.get("angle_per_gate", None) + phase_offset = self.analysis_options.get("phase_offset") + + if angle_per_gate is None: + raise CalibrationError( + f"Unknown angle_per_gate for {self.__class__.__name__}. " + "Please set it in the analysis options." + ) + + circuit = QuantumCircuit(1) + circuit.x(0) + circuit.measure_all() + + circuit.metadata = { + "experiment_type": self._type, + "qubits": self.physical_qubits, + "xval": (np.pi - phase_offset) / angle_per_gate, + "unit": "gate number", + } + + circuits.append(circuit) + + for repetition in repetitions: + circuit = self._pre_circuit() + + for _ in range(repetition): + circuit.append(self.experiment_options.gate, (0,)) + + circuit.measure_all() + + circuit.metadata = { + "experiment_type": self._type, + "qubits": self.physical_qubits, + "xval": repetition, + "unit": "gate number", + } + + circuits.append(circuit) + + return circuits + + +class FineXAmplitude(FineAmplitude): + r"""A fine amplitude experiment with all the options set for the :math:`\pi`-rotation. + + # section: overview + + :class:`FineXAmplitude` is a subclass of :class:`FineAmplitude` and is used to set + the appropriate values for the default options. + """ + + def __init__(self, qubit: int): + """Initialize the experiment.""" + super().__init__(qubit, XGate()) + + @classmethod + def _default_experiment_options(cls) -> Options: + r"""Default values for the fine amplitude experiment. + + Experiment Options: + gate (Gate): FineXAmplitude calibrates an XGate. + add_sx (bool): This option is True by default when calibrating gates with a target + angle per gate of :math:`\pi` as this increases the sensitivity of the + experiment. + add_xp_circuit (bool): This option is True by default when calibrating gates with + a target angle per gate of :math:`\pi`. + """ + options = super()._default_experiment_options() + options.gate = XGate() + options.add_sx = True + options.add_xp_circuit = True + + return options + + @classmethod + def _default_analysis_options(cls) -> Options: + """Default analysis options.""" + options = super()._default_analysis_options() + options.angle_per_gate = np.pi + options.phase_offset = np.pi / 2 + + return options + + +class FineSXAmplitude(FineAmplitude): + r"""A fine amplitude experiment with all the options set for the :math:`\pi/2`-rotation. + + # section: overview + + :class:`FineSXAmplitude` is a subclass of :class:`FineAmplitude` and is used to set + the appropriate values for the default options. + """ + + def __init__(self, qubit: int): + """Initialize the experiment.""" + super().__init__(qubit, SXGate()) + + @classmethod + def _default_experiment_options(cls) -> Options: + r"""Default values for the fine amplitude experiment. + + Experiment Options: + gate (Gate): FineSXAmplitude calibrates an SXGate. + add_sx (bool): This option is False by default when calibrating gates with a target + angle per gate of :math:`\pi/2` as this increases the sensitivity of the + experiment. + add_xp_circuit (bool): This option is False by default when calibrating gates with + a target angle per gate of :math:`\pi/2`. + repetitions (List[int]): By default the repetitions take on odd numbers for + :math:`\pi/2` target angles as this ideally prepares states on the equator of + the Bloch sphere. Note that the repetitions include two repetitions which + plays the same role as including a circuit with an X gate. + """ + options = super()._default_experiment_options() + options.gate = SXGate() + options.add_sx = False + options.add_xp_circuit = False + options.repetitions = [1, 2, 3, 5, 7, 9, 11, 13, 15, 17, 21, 23, 25] + + return options + + @classmethod + def _default_analysis_options(cls) -> Options: + """Default analysis options.""" + options = super()._default_analysis_options() + options.angle_per_gate = np.pi / 2 + options.phase_offset = 0 + + return options diff --git a/test/calibration/experiments/test_fine_amplitude.py b/test/calibration/experiments/test_fine_amplitude.py index c5e1b47704..b7a9964257 100644 --- a/test/calibration/experiments/test_fine_amplitude.py +++ b/test/calibration/experiments/test_fine_amplitude.py @@ -10,10 +10,11 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -"""Test the fine amplitude calibration experiment.""" +"""Test the fine amplitude characterization and calibration experiments.""" import numpy as np +from qiskit.circuit import Gate from qiskit.circuit.library import XGate, SXGate from qiskit.test import QiskitTestCase from qiskit.pulse import DriveChannel, Drag @@ -21,34 +22,21 @@ from qiskit_experiments.library import FineAmplitude, FineXAmplitude, FineSXAmplitude from qiskit_experiments.test.mock_iq_backend import MockFineAmp -from qiskit_experiments.exceptions import CalibrationError class TestFineAmpEndToEnd(QiskitTestCase): """Test the drag experiment.""" - def setUp(self): - """Setup some schedules.""" - super().setUp() - - with pulse.build(name="xp") as xp: - pulse.play(Drag(duration=160, amp=0.208519, sigma=40, beta=0.0), DriveChannel(0)) - - self.x_plus = xp - def test_end_to_end_under_rotation(self): """Test the experiment end to end.""" - amp_cal = FineAmplitude(0) - amp_cal.set_schedule( - schedule=self.x_plus, angle_per_gate=np.pi, add_xp_circuit=True, add_sx=True - ) - amp_cal.set_analysis_options(number_guesses=11) + amp_exp = FineAmplitude(0, Gate("xp", 1, [])) + amp_exp.set_analysis_options(number_guesses=11, angle_per_gate=np.pi) + amp_exp.set_transpile_options(basis_gates=["xp", "x"]) backend = MockFineAmp(-np.pi * 0.07, np.pi, "xp") - expdata = amp_cal.run(backend) - expdata.block_for_results() + expdata = amp_exp.run(backend).block_for_results() result = expdata.analysis_results(1) d_theta = result.value.value @@ -60,33 +48,23 @@ def test_end_to_end_under_rotation(self): def test_end_to_end_over_rotation(self): """Test the experiment end to end.""" - amp_cal = FineAmplitude(0) - amp_cal.set_schedule( - schedule=self.x_plus, angle_per_gate=np.pi, add_xp_circuit=True, add_sx=True - ) - amp_cal.set_analysis_options(number_guesses=6) + amp_exp = FineAmplitude(0, Gate("xp", 1, [])) + amp_exp.set_analysis_options(number_guesses=6, angle_per_gate=np.pi) + amp_exp.set_transpile_options(basis_gates=["xp", "x"]) backend = MockFineAmp(np.pi * 0.07, np.pi, "xp") - expdata = amp_cal.run(backend) - expdata.block_for_results() + expdata = amp_exp.run(backend).block_for_results() result = expdata.analysis_results(1) d_theta = result.value.value tol = 0.04 + print(d_theta, backend.angle_error) + self.assertTrue(abs(d_theta - backend.angle_error) < tol) self.assertEqual(result.quality, "good") - def test_zero_angle_per_gate(self): - """Test that we cannot set angle per gate to zero.""" - amp_cal = FineAmplitude(0) - - with self.assertRaises(CalibrationError): - amp_cal.set_schedule( - schedule=self.x_plus, angle_per_gate=0.0, add_xp_circuit=True, add_sx=True - ) - class TestFineAmplitudeCircuits(QiskitTestCase): """Test the circuits.""" @@ -105,28 +83,25 @@ def setUp(self): self.x_90_plus = x90p def test_xp(self): - """Test a circuit with xp.""" + """Test a circuit with the x gate.""" - amp_cal = FineAmplitude(0) - amp_cal.set_schedule( - schedule=self.x_plus, angle_per_gate=np.pi, add_xp_circuit=False, add_sx=True - ) + amp_cal = FineXAmplitude(0) + circs = amp_cal.circuits() - for idx, circ in enumerate(amp_cal.circuits()): + self.assertTrue(circs[0].data[0][0].name == "x") + + for idx, circ in enumerate(circs[1:]): self.assertTrue(circ.data[0][0].name == "sx") - self.assertEqual(circ.count_ops().get("xp", 0), idx) + self.assertEqual(circ.count_ops().get("x", 0), idx) def test_x90p(self): """Test circuits with an x90p pulse.""" - amp_cal = FineAmplitude(0) - amp_cal.set_schedule( - schedule=self.x_90_plus, angle_per_gate=np.pi, add_xp_circuit=False, add_sx=False - ) + amp_cal = FineSXAmplitude(0) + expected = [1, 2, 3, 5, 7, 9, 11, 13, 15, 17, 21, 23, 25] for idx, circ in enumerate(amp_cal.circuits()): - self.assertTrue(circ.data[0][0].name != "sx") - self.assertEqual(circ.count_ops().get("x90p", 0), idx) + self.assertEqual(circ.count_ops().get("sx", 0), expected[idx]) class TestSpecializations(QiskitTestCase): @@ -141,7 +116,7 @@ def test_fine_x_amp(self): self.assertTrue(exp.experiment_options.add_xp_circuit) self.assertEqual(exp.analysis_options.angle_per_gate, np.pi) self.assertEqual(exp.analysis_options.phase_offset, np.pi / 2) - self.assertEqual(exp.experiment_options.gate_type, XGate) + self.assertEqual(exp.experiment_options.gate, XGate()) def test_fine_sx_amp(self): """Test the fine SX amplitude.""" @@ -155,22 +130,21 @@ def test_fine_sx_amp(self): self.assertEqual(exp.experiment_options.repetitions, expected) self.assertEqual(exp.analysis_options.angle_per_gate, np.pi / 2) self.assertEqual(exp.analysis_options.phase_offset, 0) - self.assertEqual(exp.experiment_options.gate_type, SXGate) + self.assertEqual(exp.experiment_options.gate, SXGate()) - def test_end_to_end_no_schedule(self): - """Test the experiment end to end.""" - amp_cal = FineXAmplitude(0) - amp_cal.set_analysis_options(number_guesses=11) +class TestFineAmplitudeCal(QiskitTestCase): + """A class to test the fine amplitude calibration experiments.""" - backend = MockFineAmp(-np.pi * 0.07, np.pi, "x") + def setUp(self): + """Setup the tests""" - expdata = amp_cal.run(backend).block_for_results() - result = expdata.analysis_results(1) - d_theta = result.value.value + # TODO setup an instance of cals. - tol = 0.04 + def test_transpile_cals(self): + """Test that we can transpile in the calibrations before and after update.""" + self.fail("TODO") - self.assertTrue(abs(d_theta - backend.angle_error) < tol) - self.assertEqual(result.quality, "good") - self.assertIsNone(amp_cal.experiment_options.schedule) + def test_options(self): + """Test that the options are properly set for the subclasses.""" + self.fail("TODO") From 280738a9ab9b9b8b70ea92f43a78fb027714b83a Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 21 Oct 2021 12:11:19 +0200 Subject: [PATCH 02/19] * Added tests. * Added transpile options. --- .../library/calibration/fine_amplitude.py | 31 +++- .../experiments/test_fine_amplitude.py | 136 ++++++++++++++++-- 2 files changed, 152 insertions(+), 15 deletions(-) diff --git a/qiskit_experiments/library/calibration/fine_amplitude.py b/qiskit_experiments/library/calibration/fine_amplitude.py index 0c3094870b..0f477a4c03 100644 --- a/qiskit_experiments/library/calibration/fine_amplitude.py +++ b/qiskit_experiments/library/calibration/fine_amplitude.py @@ -59,6 +59,7 @@ def __init__( self.transpile_options.inst_map = calibrations.default_inst_map + @classmethod def _default_experiment_options(cls): """Default values for the fine amplitude calibration experiment. @@ -69,7 +70,7 @@ def _default_experiment_options(cls): to the value "default". """ - options = super()._default_transpile_options() + options = super()._default_experiment_options() options.result_index = -1 options.target_angle = np.pi @@ -135,6 +136,20 @@ def _default_experiment_options(cls) -> Options: return options + @classmethod + def _default_transpile_options(cls): + """Default transpile options. + + Transpile Options: + basis_gates (list(str)): A list of basis gates needed for this experiment. + The schedules for these basis gates will be provided by the instruction + schedule map from the calibrations. + """ + options = super()._default_transpile_options() + options.basis_gates = ["x", "sx"] + + return options + @classmethod def _default_analysis_options(cls) -> Options: """Default analysis options.""" @@ -171,6 +186,20 @@ def _default_experiment_options(cls) -> Options: options.target_angle = np.pi / 2 return options + @classmethod + def _default_transpile_options(cls): + """Default transpile options. + + Transpile Options: + basis_gates (list(str)): A list of basis gates needed for this experiment. + The schedules for these basis gates will be provided by the instruction + schedule map from the calibrations. + """ + options = super()._default_transpile_options() + options.basis_gates = ["x", "sx"] + + return options + @classmethod def _default_analysis_options(cls) -> Options: """Default analysis options.""" diff --git a/test/calibration/experiments/test_fine_amplitude.py b/test/calibration/experiments/test_fine_amplitude.py index b7a9964257..98dfa5c8c8 100644 --- a/test/calibration/experiments/test_fine_amplitude.py +++ b/test/calibration/experiments/test_fine_amplitude.py @@ -14,13 +14,22 @@ import numpy as np +from qiskit import transpile from qiskit.circuit import Gate from qiskit.circuit.library import XGate, SXGate from qiskit.test import QiskitTestCase from qiskit.pulse import DriveChannel, Drag import qiskit.pulse as pulse -from qiskit_experiments.library import FineAmplitude, FineXAmplitude, FineSXAmplitude +from qiskit_experiments.library import ( + FineAmplitude, + FineXAmplitude, + FineSXAmplitude, + FineXAmplitudeCal, + FineSXAmplitudeCal, +) +from qiskit_experiments.calibration_management.basis_gate_library import FixedFrequencyTransmon +from qiskit_experiments.calibration_management import BackendCalibrations from qiskit_experiments.test.mock_iq_backend import MockFineAmp @@ -31,8 +40,11 @@ def test_end_to_end_under_rotation(self): """Test the experiment end to end.""" amp_exp = FineAmplitude(0, Gate("xp", 1, [])) - amp_exp.set_analysis_options(number_guesses=11, angle_per_gate=np.pi) - amp_exp.set_transpile_options(basis_gates=["xp", "x"]) + amp_exp.set_transpile_options(basis_gates=["xp", "x", "sx"]) + amp_exp.set_experiment_options(add_sx=True) + amp_exp.set_analysis_options( + number_guesses=11, angle_per_gate=np.pi, phase_offset=np.pi / 2 + ) backend = MockFineAmp(-np.pi * 0.07, np.pi, "xp") @@ -49,8 +61,11 @@ def test_end_to_end_over_rotation(self): """Test the experiment end to end.""" amp_exp = FineAmplitude(0, Gate("xp", 1, [])) - amp_exp.set_analysis_options(number_guesses=6, angle_per_gate=np.pi) - amp_exp.set_transpile_options(basis_gates=["xp", "x"]) + amp_exp.set_transpile_options(basis_gates=["xp", "x", "sx"]) + amp_exp.set_experiment_options(add_sx=True) + amp_exp.set_analysis_options( + number_guesses=11, angle_per_gate=np.pi, phase_offset=np.pi / 2 + ) backend = MockFineAmp(np.pi * 0.07, np.pi, "xp") @@ -60,8 +75,6 @@ def test_end_to_end_over_rotation(self): tol = 0.04 - print(d_theta, backend.angle_error) - self.assertTrue(abs(d_theta - backend.angle_error) < tol) self.assertEqual(result.quality, "good") @@ -138,13 +151,108 @@ class TestFineAmplitudeCal(QiskitTestCase): def setUp(self): """Setup the tests""" + super().setUp() + + library = FixedFrequencyTransmon() + + self.backend = MockFineAmp(-np.pi * 0.07, np.pi, "xp") + self.cals = BackendCalibrations(self.backend, library) + + def test_cal_options(self): + """Test that the options are properly propagated.""" + + # Test the X gate cal + amp_cal = FineXAmplitudeCal(0, self.cals, "x") + + exp_opt = amp_cal.experiment_options + + self.assertEqual(exp_opt.gate.name, "x") + self.assertTrue(exp_opt.add_sx) + self.assertTrue(exp_opt.add_xp_circuit) + self.assertEqual(exp_opt.result_index, -1) + self.assertEqual(exp_opt.group, "default") + self.assertTrue(np.allclose(exp_opt.target_angle, np.pi)) + + # Test the SX gate cal + amp_cal = FineSXAmplitudeCal(0, self.cals, "sx") + + exp_opt = amp_cal.experiment_options + + self.assertEqual(exp_opt.gate.name, "sx") + self.assertFalse(exp_opt.add_sx) + self.assertFalse(exp_opt.add_xp_circuit) + self.assertEqual(exp_opt.result_index, -1) + self.assertEqual(exp_opt.group, "default") + self.assertTrue(np.allclose(exp_opt.target_angle, np.pi / 2)) + + + def test_run_x_cal(self): + """Test that we can transpile in the calibrations before and after update. + + If this test passes then we were successful in running a calibration experiment, + updating a pulse parameter, having this parameter propagated to the schedules + for use the next time the experiment is run. + """ + + # Initial pulse amplitude + init_amp = 0.5 + + amp_cal = FineXAmplitudeCal(0, self.cals, "x") + + circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) + + with pulse.build(name="x") as expected_x: + pulse.play(pulse.Drag(160, 0.5, 40, 0), pulse.DriveChannel(0)) + + with pulse.build(name="sx") as expected_sx: + pulse.play(pulse.Drag(160, 0.25, 40, 0), pulse.DriveChannel(0)) + + self.assertEqual(circs[5].calibrations["x"][((0, ), ())], expected_x) + self.assertEqual(circs[5].calibrations["sx"][((0,), ())], expected_sx) + + # run the calibration experiment. This should update the amp parameter of x which we test. + exp_data = amp_cal.run(self.backend).block_for_results() + d_theta = exp_data.analysis_results(1).value.value + new_amp = init_amp * np.pi / (np.pi + d_theta) + + circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) + + x_cal = circs[5].calibrations["x"][((0, ), ())] + + # Requires allclose due to numerical precision. + self.assertTrue(np.allclose(x_cal.blocks[0].pulse.amp, new_amp)) + self.assertFalse(np.allclose(x_cal.blocks[0].pulse.amp, init_amp)) + self.assertEqual(circs[5].calibrations["sx"][((0,), ())], expected_sx) + + def test_run_sx_cal(self): + """Test that we can transpile in the calibrations before and after update. + + If this test passes then we were successful in running a calibration experiment, + updating a pulse parameter, having this parameter propagated to the schedules + for use the next time the experiment is run. + """ + + # Initial pulse amplitude + init_amp = 0.5 + + amp_cal = FineSXAmplitudeCal(0, self.cals, "sx") + + circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) + + with pulse.build(name="sx") as expected_sx: + pulse.play(pulse.Drag(160, 0.25, 40, 0), pulse.DriveChannel(0)) + + self.assertEqual(circs[5].calibrations["sx"][((0,), ())], expected_sx) + + # run the calibration experiment. This should update the amp parameter of x which we test. + exp_data = amp_cal.run(self.backend).block_for_results() + d_theta = exp_data.analysis_results(1).value.value + new_amp = init_amp * (np.pi / 2) / (np.pi / 2 + d_theta) - # TODO setup an instance of cals. + circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) - def test_transpile_cals(self): - """Test that we can transpile in the calibrations before and after update.""" - self.fail("TODO") + sx_cal = circs[5].calibrations["sx"][((0,), ())] - def test_options(self): - """Test that the options are properly set for the subclasses.""" - self.fail("TODO") + # Requires allclose due to numerical precision. + self.assertTrue(np.allclose(sx_cal.blocks[0].pulse.amp, new_amp)) + self.assertFalse(np.allclose(sx_cal.blocks[0].pulse.amp, init_amp)) From 4c4a3c808c6f7bae4630302bd9541c215787fda7 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 21 Oct 2021 12:22:42 +0200 Subject: [PATCH 03/19] * Removed obsolete test. * Black --- .../library/calibration/fine_amplitude.py | 8 ++--- .../experiments/test_fine_amplitude.py | 5 ++- test/calibration/test_update_library.py | 32 ------------------- 3 files changed, 6 insertions(+), 39 deletions(-) diff --git a/qiskit_experiments/library/calibration/fine_amplitude.py b/qiskit_experiments/library/calibration/fine_amplitude.py index 0f477a4c03..b49f3bc2b6 100644 --- a/qiskit_experiments/library/calibration/fine_amplitude.py +++ b/qiskit_experiments/library/calibration/fine_amplitude.py @@ -44,7 +44,7 @@ def __init__( calibrations: The calibrations instance with the schedules. schedule_name: The name of the schedule to calibrate. cal_parameter_name: The name of the parameter in the schedule to update. - auto_update: Weather or not to automatically update the calibrations. By + auto_update: Whether or not to automatically update the calibrations. By default this variable is set to True. """ @@ -54,7 +54,7 @@ def __init__( Gate(name=schedule_name, num_qubits=1, params=[]), schedule_name=schedule_name, cal_parameter_name=cal_parameter_name, - auto_update=auto_update + auto_update=auto_update, ) self.transpile_options.inst_map = calibrations.default_inst_map @@ -103,7 +103,7 @@ def update_calibrations(self, experiment_data: ExperimentData): self._param_name, experiment_data.metadata["physical_qubits"], self._sched_name, - group=group + group=group, ) BaseUpdater.add_parameter_value( @@ -112,7 +112,7 @@ def update_calibrations(self, experiment_data: ExperimentData): prev_amp * target_angle / (target_angle + d_theta), self._param_name, self._sched_name, - group + group, ) diff --git a/test/calibration/experiments/test_fine_amplitude.py b/test/calibration/experiments/test_fine_amplitude.py index 98dfa5c8c8..b862d27159 100644 --- a/test/calibration/experiments/test_fine_amplitude.py +++ b/test/calibration/experiments/test_fine_amplitude.py @@ -185,7 +185,6 @@ def test_cal_options(self): self.assertEqual(exp_opt.group, "default") self.assertTrue(np.allclose(exp_opt.target_angle, np.pi / 2)) - def test_run_x_cal(self): """Test that we can transpile in the calibrations before and after update. @@ -207,7 +206,7 @@ def test_run_x_cal(self): with pulse.build(name="sx") as expected_sx: pulse.play(pulse.Drag(160, 0.25, 40, 0), pulse.DriveChannel(0)) - self.assertEqual(circs[5].calibrations["x"][((0, ), ())], expected_x) + self.assertEqual(circs[5].calibrations["x"][((0,), ())], expected_x) self.assertEqual(circs[5].calibrations["sx"][((0,), ())], expected_sx) # run the calibration experiment. This should update the amp parameter of x which we test. @@ -217,7 +216,7 @@ def test_run_x_cal(self): circs = transpile(amp_cal.circuits(), self.backend, **amp_cal.transpile_options.__dict__) - x_cal = circs[5].calibrations["x"][((0, ), ())] + x_cal = circs[5].calibrations["x"][((0,), ())] # Requires allclose due to numerical precision. self.assertTrue(np.allclose(x_cal.blocks[0].pulse.amp, new_amp)) diff --git a/test/calibration/test_update_library.py b/test/calibration/test_update_library.py index bf2265c8d5..2d7ecb0a4f 100644 --- a/test/calibration/test_update_library.py +++ b/test/calibration/test_update_library.py @@ -98,38 +98,6 @@ def test_amplitude(self): self.assertEqual(self.cals.get_schedule("x90p", qubits=self.qubit), expected) - def test_fine_amplitude(self): - """Test that we can update from a fine amplitude experiment.""" - - xp_sched = self.cals.get_schedule("xp", self.qubit) - target_angle = np.pi - - amp_cal = FineAmplitude(self.qubit) - amp_cal.set_schedule( - schedule=xp_sched, angle_per_gate=target_angle, add_xp_circuit=True, add_sx=True - ) - amp_cal.set_analysis_options(number_guesses=11) - - error = -np.pi * 0.05 - backend = MockFineAmp(error, np.pi, "xp") - - exp_data = amp_cal.run(backend) - exp_data.block_for_results() - - self.assertEqual(self.cals.get_parameter_value("amp", self.qubit, "xp"), 0.2) - - with self.assertRaises(CalibrationError): - Amplitude.update( - self.cals, exp_data, angles_schedules=[(target_angle, "amp_fail", "xp")] - ) - - Amplitude.update(self.cals, exp_data, angles_schedules=[(target_angle, "amp", "xp")]) - - new_value = 0.2 * target_angle / (target_angle + error) - self.assertAlmostEqual( - self.cals.get_parameter_value("amp", self.qubit, "xp"), new_value, places=3 - ) - class TestFrequencyUpdate(QiskitTestCase): """Test the frequency update function in the update library.""" From 4153486439b39fa3696ddaba9702f202dd60d37e Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 21 Oct 2021 13:17:57 +0200 Subject: [PATCH 04/19] * Docs and lint. --- qiskit_experiments/library/__init__.py | 9 ++++++--- test/calibration/test_update_library.py | 4 ++-- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/qiskit_experiments/library/__init__.py b/qiskit_experiments/library/__init__.py index 6e85582bcb..59749c64ca 100644 --- a/qiskit_experiments/library/__init__.py +++ b/qiskit_experiments/library/__init__.py @@ -62,6 +62,9 @@ ~characterization.EFSpectroscopy ~characterization.CrossResonanceHamiltonian ~characterization.EchoedCrossResonanceHamiltonian + ~characterization.FineAmplitude + ~characterization.FineXAmplitude + ~characterization.FineSXAmplitude .. _calibration: @@ -85,9 +88,9 @@ class instance to manage parameters and pulse schedules. ~calibration.FineSXDrag ~calibration.Rabi ~calibration.EFRabi - ~calibration.FineAmplitude - ~calibration.FineXAmplitude - ~calibration.FineSXAmplitude + ~calibration.FineAmplitudeCal + ~calibration.FineXAmplitudeCal + ~calibration.FineSXAmplitudeCal ~calibration.RamseyXY """ diff --git a/test/calibration/test_update_library.py b/test/calibration/test_update_library.py index 2d7ecb0a4f..94f97f6e58 100644 --- a/test/calibration/test_update_library.py +++ b/test/calibration/test_update_library.py @@ -22,7 +22,7 @@ import qiskit.pulse as pulse from qiskit.test.mock import FakeAthens -from qiskit_experiments.library import Rabi, FineXDrag, DragCal, QubitSpectroscopy, FineAmplitude +from qiskit_experiments.library import Rabi, FineXDrag, DragCal, QubitSpectroscopy from qiskit_experiments.calibration_management.calibrations import Calibrations from qiskit_experiments.exceptions import CalibrationError from qiskit_experiments.calibration_management.update_library import ( @@ -32,7 +32,7 @@ FineDragUpdater, ) from qiskit_experiments.calibration_management.backend_calibrations import BackendCalibrations -from qiskit_experiments.test.mock_iq_backend import DragBackend, MockFineAmp +from qiskit_experiments.test.mock_iq_backend import DragBackend from .experiments.test_fine_drag import FineDragTestBackend From aec2347dc61df4e717781c584391aa0ef4e98dcc Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 21 Oct 2021 13:30:31 +0200 Subject: [PATCH 05/19] * Docs and tests. --- qiskit_experiments/library/calibration/fine_amplitude.py | 2 +- test/calibration/experiments/test_fine_amplitude.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/qiskit_experiments/library/calibration/fine_amplitude.py b/qiskit_experiments/library/calibration/fine_amplitude.py index b49f3bc2b6..211c4a0bd3 100644 --- a/qiskit_experiments/library/calibration/fine_amplitude.py +++ b/qiskit_experiments/library/calibration/fine_amplitude.py @@ -79,7 +79,7 @@ def _default_experiment_options(cls): return options def update_calibrations(self, experiment_data: ExperimentData): - """Update the amplitude of the pulse in the calibrations. + r"""Update the amplitude of the pulse in the calibrations. The update rule of this experiment is diff --git a/test/calibration/experiments/test_fine_amplitude.py b/test/calibration/experiments/test_fine_amplitude.py index b862d27159..2ea05a5873 100644 --- a/test/calibration/experiments/test_fine_amplitude.py +++ b/test/calibration/experiments/test_fine_amplitude.py @@ -232,7 +232,7 @@ def test_run_sx_cal(self): """ # Initial pulse amplitude - init_amp = 0.5 + init_amp = 0.25 amp_cal = FineSXAmplitudeCal(0, self.cals, "sx") @@ -244,7 +244,7 @@ def test_run_sx_cal(self): self.assertEqual(circs[5].calibrations["sx"][((0,), ())], expected_sx) # run the calibration experiment. This should update the amp parameter of x which we test. - exp_data = amp_cal.run(self.backend).block_for_results() + exp_data = amp_cal.run(MockFineAmp(-np.pi * 0.07, np.pi / 2, "sx")).block_for_results() d_theta = exp_data.analysis_results(1).value.value new_amp = init_amp * (np.pi / 2) / (np.pi / 2 + d_theta) From cdf3cdd3c9f8812d2a0c1209c41e499226a8fbdb Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 21 Oct 2021 13:59:15 +0200 Subject: [PATCH 06/19] * Begining of NB reworking. --- docs/tutorials/calibrating_armonk.ipynb | 595 +++++++++++++----------- 1 file changed, 333 insertions(+), 262 deletions(-) diff --git a/docs/tutorials/calibrating_armonk.ipynb b/docs/tutorials/calibrating_armonk.ipynb index 95a538467d..712d114fec 100644 --- a/docs/tutorials/calibrating_armonk.ipynb +++ b/docs/tutorials/calibrating_armonk.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "b11c2f66", "metadata": {}, "source": [ "# Calibrating single-qubit gates on `ibmq_armonk`\n", @@ -18,6 +19,7 @@ { "cell_type": "code", "execution_count": 1, + "id": "e3836dba", "metadata": {}, "outputs": [], "source": [ @@ -34,6 +36,7 @@ { "cell_type": "code", "execution_count": 2, + "id": "87e1101f", "metadata": {}, "outputs": [], "source": [ @@ -45,6 +48,7 @@ { "cell_type": "code", "execution_count": 3, + "id": "e3f6f6c1", "metadata": {}, "outputs": [], "source": [ @@ -53,6 +57,7 @@ }, { "cell_type": "markdown", + "id": "5325fe3d", "metadata": {}, "source": [ "The two functions below show how to setup an instance of `BackendCalibrations`. To do this the user defines the template schedules to calibrate. These template schedules are fully parameterized, even the channel indices on which the pulses are played. Furthermore, the name of the parameter in the channel index must follow the convention laid out in the documentation of the calibration module. Note that the parameters in the channel indices are automatically mapped to the channel index when `get_schedule` is called. " @@ -61,6 +66,7 @@ { "cell_type": "code", "execution_count": 4, + "id": "ca0c1462", "metadata": {}, "outputs": [], "source": [ @@ -101,6 +107,7 @@ }, { "cell_type": "markdown", + "id": "31ec74cd", "metadata": {}, "source": [ "When setting up the calibrations we add three pulses: a $\\pi$-rotation, with a schedule named `xp`, a schedule `xm` identical to `xp` but with a nagative amplitude, and a $\\pi/2$-rotation, with a schedule named `x90p`. Here, we have linked the amplitude of the `xp` and `xm` pulses. Therefore, calibrating the parameters of `xp` will also calibrate the parameters of `xm`." @@ -109,6 +116,7 @@ { "cell_type": "code", "execution_count": 5, + "id": "a2f9d7e5", "metadata": {}, "outputs": [], "source": [ @@ -118,6 +126,7 @@ }, { "cell_type": "markdown", + "id": "af0cd5a0", "metadata": {}, "source": [ "A samilar setup is achieved by using a pre-built library of gates. The library of gates provides a standard set of gates and some initial guesses for the value of the parameters in the template schedules. This is shown below using the `FixedFrequencyTransmon` which provides the `x`, `y`, `sx`, and `sy` pulses. Note that in the example below we change the default value of the pulse duration to 320 samples." @@ -126,6 +135,7 @@ { "cell_type": "code", "execution_count": 6, + "id": "48895a9f", "metadata": {}, "outputs": [], "source": [ @@ -135,6 +145,7 @@ { "cell_type": "code", "execution_count": 7, + "id": "bd83e088", "metadata": {}, "outputs": [], "source": [ @@ -144,6 +155,7 @@ }, { "cell_type": "markdown", + "id": "d145b612", "metadata": {}, "source": [ "## 1. Finding qubits with spectroscopy\n", @@ -153,15 +165,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, + "id": "908ff764", "metadata": {}, "outputs": [], "source": [ - "from qiskit_experiments.library.characterization.qubit_spectroscopy import QubitSpectroscopy" + "from qiskit_experiments.library.calibration.rough_frequency import RoughFrequencyCal" ] }, { "cell_type": "markdown", + "id": "4c2699ac", "metadata": {}, "source": [ "We first show the contents of the calibrations for qubit 0. Note that the guess values that we added before apply to all qubits on the chip. We see this in the table below as an empty tuple `()` in the qubits column. Observe that the parameter values of `xm` do not appear in this table as they are given by the values of `xp`." @@ -170,6 +184,7 @@ { "cell_type": "code", "execution_count": 9, + "id": "fa22b8a4", "metadata": {}, "outputs": [ { @@ -193,155 +208,155 @@ " \n", " \n", " \n", + " parameter\n", + " qubits\n", + " schedule\n", " value\n", - " date_time\n", + " group\n", " valid\n", + " date_time\n", " exp_id\n", - " group\n", - " qubits\n", - " parameter\n", - " schedule\n", " \n", " \n", " \n", " \n", " 0\n", - " 4.971648e+09\n", - " 2021-07-30 17:53:14.422767+0000\n", - " True\n", - " None\n", + " σ\n", + " ()\n", + " x\n", + " 8.000000e+01\n", " default\n", - " (0,)\n", - " qubit_lo_freq\n", + " True\n", + " 2021-10-21 13:31:28.997950+0200\n", " None\n", " \n", " \n", " 1\n", - " 8.000000e+01\n", - " 2021-07-30 17:53:14.422985+0000\n", - " True\n", - " None\n", - " default\n", + " amp\n", " ()\n", - " σ\n", " x\n", + " 5.000000e-01\n", + " default\n", + " True\n", + " 2021-10-21 13:31:28.997896+0200\n", + " None\n", " \n", " \n", " 2\n", - " 8.000000e+01\n", - " 2021-07-30 17:53:14.422990+0000\n", - " True\n", + " meas_lo_freq\n", + " (0,)\n", " None\n", + " 6.993371e+09\n", " default\n", - " ()\n", - " σ\n", - " sx\n", + " True\n", + " 2021-10-21 13:31:28.997584+0200\n", + " None\n", " \n", " \n", " 3\n", - " 6.993371e+09\n", - " 2021-07-30 17:53:14.422786+0000\n", - " True\n", - " None\n", + " β\n", + " ()\n", + " sx\n", + " 0.000000e+00\n", " default\n", - " (0,)\n", - " meas_lo_freq\n", + " True\n", + " 2021-10-21 13:31:28.998004+0200\n", " None\n", " \n", " \n", " 4\n", - " 0.000000e+00\n", - " 2021-07-30 17:53:14.422964+0000\n", + " duration\n", + " ()\n", + " sx\n", + " 3.200000e+02\n", + " default\n", " True\n", + " 2021-10-21 13:31:28.997996+0200\n", " None\n", - " default\n", - " ()\n", - " β\n", - " x\n", " \n", " \n", " 5\n", + " duration\n", + " ()\n", + " x\n", " 3.200000e+02\n", - " 2021-07-30 17:53:14.422981+0000\n", + " default\n", " True\n", + " 2021-10-21 13:31:28.997932+0200\n", " None\n", - " default\n", - " ()\n", - " duration\n", - " x\n", " \n", " \n", " 6\n", - " 5.000000e-01\n", - " 2021-07-30 17:53:14.422975+0000\n", + " σ\n", + " ()\n", + " sx\n", + " 8.000000e+01\n", + " default\n", " True\n", + " 2021-10-21 13:31:28.998011+0200\n", " None\n", - " default\n", - " ()\n", - " amp\n", - " x\n", " \n", " \n", " 7\n", - " 2.500000e-01\n", - " 2021-07-30 17:53:14.422995+0000\n", - " True\n", + " qubit_lo_freq\n", + " (0,)\n", " None\n", + " 4.971593e+09\n", " default\n", - " ()\n", - " amp\n", - " sx\n", + " True\n", + " 2021-10-21 13:31:28.997535+0200\n", + " None\n", " \n", " \n", " 8\n", - " 0.000000e+00\n", - " 2021-07-30 17:53:14.423004+0000\n", - " True\n", - " None\n", - " default\n", + " amp\n", " ()\n", - " β\n", " sx\n", + " 2.500000e-01\n", + " default\n", + " True\n", + " 2021-10-21 13:31:28.997983+0200\n", + " None\n", " \n", " \n", " 9\n", - " 3.200000e+02\n", - " 2021-07-30 17:53:14.422999+0000\n", + " β\n", + " ()\n", + " x\n", + " 0.000000e+00\n", + " default\n", " True\n", + " 2021-10-21 13:31:28.997875+0200\n", " None\n", - " default\n", - " ()\n", - " duration\n", - " sx\n", " \n", " \n", "\n", "" ], "text/plain": [ - " value date_time valid exp_id group \\\n", - "0 4.971648e+09 2021-07-30 17:53:14.422767+0000 True None default \n", - "1 8.000000e+01 2021-07-30 17:53:14.422985+0000 True None default \n", - "2 8.000000e+01 2021-07-30 17:53:14.422990+0000 True None default \n", - "3 6.993371e+09 2021-07-30 17:53:14.422786+0000 True None default \n", - "4 0.000000e+00 2021-07-30 17:53:14.422964+0000 True None default \n", - "5 3.200000e+02 2021-07-30 17:53:14.422981+0000 True None default \n", - "6 5.000000e-01 2021-07-30 17:53:14.422975+0000 True None default \n", - "7 2.500000e-01 2021-07-30 17:53:14.422995+0000 True None default \n", - "8 0.000000e+00 2021-07-30 17:53:14.423004+0000 True None default \n", - "9 3.200000e+02 2021-07-30 17:53:14.422999+0000 True None default \n", + " parameter qubits schedule value group valid \\\n", + "0 σ () x 8.000000e+01 default True \n", + "1 amp () x 5.000000e-01 default True \n", + "2 meas_lo_freq (0,) None 6.993371e+09 default True \n", + "3 β () sx 0.000000e+00 default True \n", + "4 duration () sx 3.200000e+02 default True \n", + "5 duration () x 3.200000e+02 default True \n", + "6 σ () sx 8.000000e+01 default True \n", + "7 qubit_lo_freq (0,) None 4.971593e+09 default True \n", + "8 amp () sx 2.500000e-01 default True \n", + "9 β () x 0.000000e+00 default True \n", "\n", - " qubits parameter schedule \n", - "0 (0,) qubit_lo_freq None \n", - "1 () σ x \n", - "2 () σ sx \n", - "3 (0,) meas_lo_freq None \n", - "4 () β x \n", - "5 () duration x \n", - "6 () amp x \n", - "7 () amp sx \n", - "8 () β sx \n", - "9 () duration sx " + " date_time exp_id \n", + "0 2021-10-21 13:31:28.997950+0200 None \n", + "1 2021-10-21 13:31:28.997896+0200 None \n", + "2 2021-10-21 13:31:28.997584+0200 None \n", + "3 2021-10-21 13:31:28.998004+0200 None \n", + "4 2021-10-21 13:31:28.997996+0200 None \n", + "5 2021-10-21 13:31:28.997932+0200 None \n", + "6 2021-10-21 13:31:28.998011+0200 None \n", + "7 2021-10-21 13:31:28.997535+0200 None \n", + "8 2021-10-21 13:31:28.997983+0200 None \n", + "9 2021-10-21 13:31:28.997875+0200 None " ] }, "execution_count": 9, @@ -357,29 +372,31 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, + "id": "502aef29", "metadata": {}, "outputs": [], "source": [ "freq01_estimate = backend.defaults().qubit_freq_est[qubit]\n", "frequencies = np.linspace(freq01_estimate -15e6, freq01_estimate + 15e6, 51)\n", - "spec = QubitSpectroscopy(qubit, frequencies)\n", + "spec = RoughFrequencyCal(qubit, cals, frequencies)\n", "spec.set_experiment_options(amp=0.1)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, + "id": "91184061", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAATYAAAB7CAYAAAD+DayvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAASvUlEQVR4nO3de3RNd97H8feR+x1RSQSJuMR9lKMJbQgiqUTFikhrHp0aNJWJW8ZT0kUkLm3TMsFDlRmN1qIzQqpFoxUzQtCLVFUEkQwhVFIJRdLjksvzh+W0RxI56iQ7tu9rLWud/PZv//Z3nxWf/PbtHE11dXU1QgihIs2ULkAIIUxNgk0IoToSbEII1ZFgE0KojgSbEEJ1JNiEEKojwSaEUB0JNiGE6kiwCSFUR4JNCKE6EmxCCNWRYBNCqI4EmxBCdSTYhBCqI8EmhFAdCTYhhOpIsAkhVEeCTQihOhJsQgjVMVe6ACGeFKdOnaq3z6pVq5g6deoD+3Tt2tVUJamWzNiEaELee+89pUtQBQk2IYTqSLAJIVRHgk2IJmTr1q1Kl6AKEmxCCNWRYBOiCQkPD1e6BFWQ2z0EALn/gRs/KV1F43BoDd5Dla6iaZk5cyZHjx5t9O326dOH5cuXm3xcCTYB3A21ny8oXYVQytGjR9m3b5/SZZiMHIoK0YRER0crXYIqSLAJ0YTU99SBMI4EmxBNyKBBg5QuQRUk2IRoQi5fvqx0CaogwSaEUB25KipM4lLpGf6RNofjZzLR3S7DwaYFXdpqmTt+MxbmlkqX99jo3r270iWoggSbMIm5HwTTr0sg62fnYmvtSMm1i3x9cifVVCtd2mMlNTVV6RIajJOTE9euXWuUbUmwiUd2vbyUwsu5xL/yCXY2TgA81bwtLwyYAsCG3Qlkn83Ey6036d9twMrChtCBU3lpaKx+jLNFx1m7Yxb5F49gaWHDsKf/h1eCFmJuZgFA0ZUC/v756+ScPcCtOzo8XHqw6M/bcbRzbvwdbkDz589n4cKFSpfxQB06dGD06NFotVq8vb2xtLSkrKyM7Oxsvv32W1JTU/n5558N1unYsSN79+5l9erVJCYmNniNco5NPDJHO2c8XXqQtGUy6VkbOFd8gupqw5la9pn9tLB3YXPcJRZM+IzU/Un85/uPAbha9hOz3h/Mcz3D+Oe8i/zf1K/4Li+df/7nbQBu3v6F19cOpblda5JfP0VqQgmvvfA3zM3Ud4i7ZcsWpUuoU+/evdm5cyf5+fkkJSXxxz/+kX79+tGrVy8GDBhAZGQk69at4+LFi6xdu5annnoK+DXU2rVrx4gRIzA3b/j5lASbMImlURn07ujPJweWM2VZHyIWuLAxfZE+4Fo6uvHikDlYmFvSpW0/gn0j+fLwhwDsydpAR7c/MHLAa1iYW9LKyZ1xQ95gz3cbAPjm5E5u39ERHboCOxsnzMzM6e7hi621g1K7+0TRaDTMmzePrKwsQkJCuH37Nps2beLVV1/F19eX3r174+/vT0xMDOnp6dja2hIZGUlOTg5RUVH6UMvMzCQ4OJiKiooGr1kORRW2bds24uLiyMvLw8PDg9mzZ3PgwAEyMjIoKChQujyjOdm1YtKIt5g04i1u3v6FfT+ksGzrq7RycgfApYUHGo1G39+lhScHsj8B4NKVs+QUHGR0XHP98mqqqaqqBO4ehrq29MLMTH5dG5tGoyE5OZkJEyYAdz/hNz4+ntLS0hp99+3bx/Lly/H29mbVqlUEBASwevVqADIzMxkxYgTl5eWNUrf8pijoiy++YMyYMQQEBPDWW29RXl5OfHw8Op0OMzMzpcv73awtbQnqP4HPDq7kvz8excG2JcVXz1FdXa0Pt+KrBbRyagvcDb2nOwfw5qTPax3PtaUnRVfPUllViVmzx/d9MUZTe15z0aJFTJgwgbKyMsLDw/nyyy/rXSc3N5cpU6aQlZVF8+bNAVixYkWjhRrIoaii5s+fj6enJ2lpaYwaNYpx48aRnp5OcXGx0qU9lBu/XOWDtDc4W3Sciso7VFZWkHkslYKi4/Ts4AfAleuXSMlYQkXlHfIvfk/aN/8gUPsKAMP7/YnTF7L44ttkbt+5SVVVFZdKz3D41BcAPNMtBAszS9Zsj6Fcd43KygpOnPuaX27eUGyfG0pOTo7SJej5+PgQGxtLZWUloaGhRoUa/HpOrXnz5vqjjpUrV9KiRYsGrNaQpvr+s7yiUZSXl+Pg4MCsWbNYsmSJwTJ/f38KCgrqPRT97aHdo1o6ZS9/6Oj/u9bV3S5n9afTyT6byZUblzBrZo5LC09G+k5h5IDX7l4VPbMfrzZ/IP27DViaWzNqYDTjhr6h34dzxSdYlxZL7vlvuVWhw7WFJyG+rzFq4F+Au/fJrd0xi5yCg9ypvE0Ht14smPAZjrYtH7reH/6bwf+uGfK79vVRxMTE1Ntn2bJl9fZbtmyZqUp6oK+++gpfX1/effdd5syZY9Q6v71QkJmZSUhICGlpaTz33HMsXbqU119//ZFqMjau5FBUIVevXqW6uhpXV9cay1xdXR+r82s2lnbMivjggX00mmZEjVpG1Kja/1N6uHRn0Z+317m+m7MXCRO2PVKdwnh9+/bF19eXq1evkpCQYNQ694favXNqMTExHD58mIkTJxIXF8fNmzcbtngk2BTTokULNBoNRUVFNZbV1lYbU062s/715Hwe2+DB/lS/3/gHKsZ8r+iyZcuIjIx8YJ+kpCRTlaTn7+9vcH7vpZdeAuCjjz5Cp9PVu35doQaQlZVFVlYWWq2WwMBAtm//9Q/Y4MGDycjIMO3OIOfYFGNnZ4dWqyU1NdXg8ve5c+c4dOiQgpUJJS1YsEDpEgDQarUApKen19v3QaF2z549ewzGbWgyY1PQwoULCQ4OJjg4mGnTplFWVkZCQgIuLi5Kl2ZSfwpMULqEx0ZERITSJQDQo0cPAH744YcH9jMm1AD9x47fG7ehSbAp6Pnnn2fr1q3ExcUxZswYPDw8iI2NJTMzs0Gm56Lp69atGydPnlS6DJKSknB0dKSkpOSB/TZt2lRvqMHdYFu8eDEnTpxoiHJrkGBTWFhYGGFhYQZtmZmZClUjxF3vvPOOUf1efvllFi9ezMSJEx94n1pubi5xcXGmKq9eEmzCaCXXfiRu/UjOFZ9gx+IyzMzMKbpSwLSVPrRv3Q1zM0veidwNwPvbYzh9IYtO7n2JDl1RZ9vD9H2YMetbJkwjLy+PF198UekyapCLB8JojrYteTfy33Rr72vQ3q/zcP4WlaEPtbwLR9DdKmPZXzKpqLhNbuHhWtsepu/DjFnXuI8Df39/pUtQBZmxNUEffvih0iXUytLCGksL6xrtR/+7l5jVfjzXM4wxg2I4ef5r+nUZDkDfzgGcOPcVZs3Ma7R5t+tvdF9j27zb9Qeoddx7y5qy999/X+kSVEFmbOKRtHR0Y/2c0yx9bS9H8vZw5sdjlOl+xtbKEQA7ayfKdD/X2gYY3fdhxqxr3MdBVFSU0iWogszYRA1Xrhfx5qaXDNpaOrgyd/y/avS1NLcCrADw7TaSguLj2Fk78cut6wCU37qOvU1zmmnMarQBRvc1tu2e2sZ9HMjVcNOQGZuooaWjK3+LyjD4V1uoAQYPoucUHMTNuSPdPQbwfd6/Afg+bw/d2vvW2gYY3fdhxqxrXPHkkGATRquovMPstQGcufQDseuCOHn+G7LPZvKX5f2YsWogzk7udGvvQ+e2fbGwsCZmtR/NmpnRtf0ztbYBRvc1tu3K9SI2/fvNOrcnngzy6R4CeLKeFW3eFrQv1d/P1Ix5VtQYXbt2Nck4v3X/s6KNRZ4VFeIJkJKSonQJqiAXDwQADq2VrqDxNOV9jY+PV+R50T59+jz0OmfOXwLAq72bweuG3q4xJNgEAN5Dla5AKGn58uUPvU7sO38HIHFOpMHrpkAORYUQqiPBJkQTcu9bncSjkWAToglprM8rUzsJNiGakMGDBytdgipIsAkhVEeCTQihOnK7hxCNxJgnBuLj4xvkyYInjczYhGhCjP0OT/FgEmxCCNWRYBNCqI4EmxBCdSTYhBCqI8EmhFAdCTYhhOpIsAkhGl1GRgY9evSgU6dOTJ48mcrKSpOOL8EmhGhUVVVVTJ48mS1btpCfn8/169fZuHGjSbchwSaEaFSHDx+mTZs2dO/eHYBJkyaRmppq0m1IsAkhGtWFCxdo166d/uf27dtTWFho0m3Is6JCCKNcKLpM6q79NdpXrE+t8drK0oJXxgRhY21Vo39jfDGezNiEEEZp6/oUbVycufRTKZd+KtW33//60k+l9OvVpdZQA2jXrp3BDO38+fO0bdvWpLVKsAkhjPbCsIG0cHJ4YJ/unT3Q9vKuc7lWq+XChQucOHECgA8++ICwsDCT1inBJoQwmrWVJWND/NHUsdze1oawoEFoNHX1ADMzM9atW0d4eDgdO3bE3t6el19+2aR1yjfBCyEeWtrer9n/7bEa7X8KC6R7Z8/GL+g+MmMTQjy0QL/+uD7V0qBN29u7SYQaSLAp4tatW0qXIMQjMTc348WRQzAzuxshLZ0ceGHoAIWr+lWTCbaEhAQ0Gg3Hjx8nJCQEe3t73NzcWLJkCQC7du2ib9++2Nra8vTTT3PgwAGD9Q8dOkRQUBBOTk7Y2Njg5+dXo09WVhYRERG0b98eGxsbOnXqxLRp07h27ZpBv/z8fMLDw3F1dcXKygp3d3dGjRpFaendqz8ZGRloNBoyMjIM1qut3d/fH61Wy+7du+nfvz/W1tYsXLgQgMLCQiZMmKDfTrdu3Vi3bp0p3k4hGpxba2cC/bRogIiRQ7CyslS6JL0mdx/b2LFjmTx5MjExMWzYsIHZs2dTWlrKzp07mTdvHg4ODsydO5fQ0FAKCgpwcHBg9+7djBw5kqFDh7J+/XqsrKx47733GDZsGAcOHKB///4AFBQU0KtXL8aPH4+TkxP5+fm8/fbbHDlyhIMHD+prCAkJwdHRkZUrV+Li4kJRURHp6enodLrftU/nzp0jMjKSuXPn0rlzZ+zs7Pjxxx/x8fHB3t6exMRE3N3dSUtLIzIykvLycmbMmFHvuLHv/P131SOEqa3ZtL1RtpM4J9Kofk0u2GbMmMGUKVMA8PPzY/v27SQlJXH69Gk8PT0BsLGxYdiwYezevZsxY8YwdepUtFotaWlpNGt2dxIaFBREz549iY+PJy0tDYDw8HCDbT377LN06dKFQYMGcfToUfr06UNJSQmnT5/m008/JTQ0VN83IiLid+9TSUkJO3fuxMfHR98WGRmJTqfjyJEjuLq6AjB8+HCuX7/OggULmDJlClZWtd8HJIR4sCYXbMHBwfrXVlZWeHl5UVlZqQ81+PXbfgoLC8nPzycvL4+ZM2dSVVVFVVWVvl9AQADr16/X/1xWVkZiYiKbN2+msLDQ4FxXbm4uffr0wdnZGS8vL2JjYykuLmbQoEGP/K1Bbm5uBqEGkJaWRmBgIK1ataKiokLf/vzzz5OcnMyxY8f0M826GPvXS4gnTZMLtpYtDa+0WFpaYm1tXaMN4ObNmxQXFwMQHR1NdHR0rWPqdDpsbGyYOHEiu3btIiEhgb59++Lg4EBhYSFhYWH6w0yNRsOePXtYuHAh8+bN4/Lly7Rt25bo6GjmzJnzwPtz6uLm5lajrbi4mJSUFFJSUmpdp6SkpN5x5VBUPGke20PRh+Xs7AzcvfgQEhJSax8rKytu3rzJtm3bmD9/PrNmzdIvu//CAUCHDh1Yv3491dXV5OTkkJyczBtvvEGrVq2YPHmyPmjvv7p57+LC/WoLQ2dnZ5555hnmz59f6zqdO3eutV0IUb/HPti8vb3x8vIiOzub+Pj4OvvdunWLiooKLCwsDNqTk5PrXEej0dCzZ0+SkpJYs2YN2dnZAHh4eACQnZ1NUFCQvv+OHTuMrjs4OJi9e/fStWtX7O3tjV7vt+RQVIjaPfbBptFoWLNmDSEhIYSGhjJ+/Hhat27N5cuXOXLkCHfu3GHJkiU4OTkxcOBAli5diouLC23atCElJYVvvvnGYLxjx44xffp0IiIi9LOmLVu2oNPp9CHm5ubGkCFDSExMxNnZGXd3dz777DP276/5yQd1WbRoET4+Pjz77LNMnz6djh07cuPGDU6dOkVGRgaff/656d4kIZ4wTeY+tkcxfPhwDh06RLNmzYiKiiIwMJCYmBhycnIYPHiwvt/HH3/MgAEDmDlzJuPGjePOnTts3rzZYCxXV1c8PT1ZsWIFo0ePZuzYsWRnZ5OSkmJwYWPjxo34+fnx17/+lXHjxlFdXc3KlSuNrtnd3Z2srCwGDhzIggULCAwMZNKkSezYsYOAgIBHf1OEeILJs6JCCNVRxYxNCCF+S4JNCKE6EmxCCNWRYBNCqI4EmxBCdSTYhBCqI8EmhFAdCTYhhOpIsAkhVEeCTQihOhJsQgjVkWATQqiOBJsQQnUk2IQQqiPBJoRQHQk2IYTqSLAJIVRHgk0IoToSbEII1ZFgE0KojgSbEEJ1JNiEEKojwSaEUB0JNiGE6kiwCSFUR4JNCKE6EmxCCNWRYBNCqM7/A3KZ7bmrCHUyAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 11, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -391,17 +408,18 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, + "id": "32a49399", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -412,46 +430,28 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, + "id": "1e24ce2a", "metadata": {}, "outputs": [], "source": [ - "spec_data = spec.run(backend)" + "spec_data = spec.run(backend).block_for_results()" ] }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ExperimentData(QubitSpectroscopy, 46bd5899-bc1d-44a1-b114-96d7cfe663cb, backend=ibmq_armonk, job_ids=['61043c91d3b44f056124661d'])" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "spec_data.block_for_results()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, + "execution_count": 16, + "id": "e880af97", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -462,7 +462,8 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, + "id": "6e8e067c", "metadata": {}, "outputs": [ { @@ -471,9 +472,9 @@ "text": [ "DbAnalysisResultV1\n", "- name: f01\n", - "- value: 4971617512.273927 ± 46140.92086748135 Hz\n", - "- χ²: 3.122087795666665\n", - "- quality: bad\n", + "- value: 4971653459.195527 ± 50071.2409732263 Hz\n", + "- χ²: 0.7294501888302608\n", + "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" ] @@ -485,25 +486,16 @@ }, { "cell_type": "markdown", + "id": "125628a5", "metadata": {}, "source": [ "We now update the instance of `Calibrations` with the value of the frequency that we measured using the `Frequency.update` function. Note that for the remainder of this notebook we use the value of the qubit frequency in the backend as it is not yet possible to updated qubit frequencies with the circuit path." ] }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "from qiskit_experiments.calibration_management.update_library import Frequency\n", - "\n", - "Frequency.update(cals, spec_data)" - ] - }, { "cell_type": "code", "execution_count": 18, + "id": "6937956d", "metadata": {}, "outputs": [ { @@ -527,48 +519,48 @@ " \n", " \n", " \n", + " parameter\n", + " qubits\n", + " schedule\n", " value\n", - " date_time\n", + " group\n", " valid\n", + " date_time\n", " exp_id\n", - " group\n", - " qubits\n", - " parameter\n", - " schedule\n", " \n", " \n", " \n", " \n", " 0\n", - " 6.993371e+09\n", - " 2021-07-30 17:53:14.422786+0000\n", - " True\n", + " qubit_lo_freq\n", + " (0,)\n", " None\n", + " 4.971593e+09\n", " default\n", - " (0,)\n", - " meas_lo_freq\n", + " True\n", + " 2021-10-21 13:31:28.997535+0200\n", " None\n", " \n", " \n", " 1\n", - " 4.971648e+09\n", - " 2021-07-30 17:53:14.422767+0000\n", - " True\n", - " None\n", - " default\n", - " (0,)\n", " qubit_lo_freq\n", + " (0,)\n", " None\n", + " 4.971653e+09\n", + " default\n", + " True\n", + " 2021-10-21 13:34:22.222000+0200\n", + " 3830f027-b9a7-40d9-9c3b-e79c817a3de3\n", " \n", " \n", " 2\n", - " 4.971618e+09\n", - " 2021-07-31 02:54:42.339000+0900\n", - " True\n", - " 46bd5899-bc1d-44a1-b114-96d7cfe663cb\n", - " default\n", + " meas_lo_freq\n", " (0,)\n", - " qubit_lo_freq\n", + " None\n", + " 6.993371e+09\n", + " default\n", + " True\n", + " 2021-10-21 13:31:28.997584+0200\n", " None\n", " \n", " \n", @@ -576,20 +568,15 @@ "" ], "text/plain": [ - " value date_time valid \\\n", - "0 6.993371e+09 2021-07-30 17:53:14.422786+0000 True \n", - "1 4.971648e+09 2021-07-30 17:53:14.422767+0000 True \n", - "2 4.971618e+09 2021-07-31 02:54:42.339000+0900 True \n", - "\n", - " exp_id group qubits parameter \\\n", - "0 None default (0,) meas_lo_freq \n", - "1 None default (0,) qubit_lo_freq \n", - "2 46bd5899-bc1d-44a1-b114-96d7cfe663cb default (0,) qubit_lo_freq \n", + " parameter qubits schedule value group valid \\\n", + "0 qubit_lo_freq (0,) None 4.971593e+09 default True \n", + "1 qubit_lo_freq (0,) None 4.971653e+09 default True \n", + "2 meas_lo_freq (0,) None 6.993371e+09 default True \n", "\n", - " schedule \n", - "0 None \n", - "1 None \n", - "2 None " + " date_time exp_id \n", + "0 2021-10-21 13:31:28.997535+0200 None \n", + "1 2021-10-21 13:34:22.222000+0200 3830f027-b9a7-40d9-9c3b-e79c817a3de3 \n", + "2 2021-10-21 13:31:28.997584+0200 None " ] }, "execution_count": 18, @@ -603,6 +590,7 @@ }, { "cell_type": "markdown", + "id": "adc314d6", "metadata": {}, "source": [ "As seen from the table above the measured frequency has been added to the calibrations." @@ -610,6 +598,7 @@ }, { "cell_type": "markdown", + "id": "351b4f8a", "metadata": {}, "source": [ "## 2. Calibrating the pulse amplitudes with a Rabi experiment\n", @@ -619,7 +608,8 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 26, + "id": "ed4a5f77", "metadata": {}, "outputs": [], "source": [ @@ -629,7 +619,8 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 27, + "id": "8227b8ba", "metadata": {}, "outputs": [], "source": [ @@ -642,38 +633,28 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 28, + "id": "68d32b29", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ExperimentData(Rabi, fb23c9c4-1ef9-4c69-a623-0ff4dad4a956, backend=ibmq_armonk, job_ids=['61043cead3b44fa02724661f'])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "rabi_data = rabi.run(backend)\n", - "rabi_data.block_for_results()" + "rabi_data = rabi.run(backend).block_for_results()" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 29, + "id": "9eefc00c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 22, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -684,7 +665,8 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 30, + "id": "444d829c", "metadata": {}, "outputs": [ { @@ -693,8 +675,8 @@ "text": [ "DbAnalysisResultV1\n", "- name: rabi_rate\n", - "- value: 0.6359584889998876 ± 0.0024230516948501703\n", - "- χ²: 2.394600326253947\n", + "- value: 0.5814882677801085 ± 0.0030396341196350686\n", + "- χ²: 1.157904323535443\n", "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" @@ -707,7 +689,8 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 31, + "id": "f883b472", "metadata": {}, "outputs": [], "source": [ @@ -716,7 +699,8 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 32, + "id": "7fa0e4b4", "metadata": {}, "outputs": [ { @@ -740,80 +724,106 @@ " \n", " \n", " \n", + " parameter\n", + " qubits\n", + " schedule\n", " value\n", - " date_time\n", + " group\n", " valid\n", + " date_time\n", " exp_id\n", - " group\n", - " qubits\n", - " parameter\n", - " schedule\n", " \n", " \n", " \n", " \n", " 0\n", - " 0.500000+0.000000j\n", - " 2021-07-30 17:53:14.422975+0000\n", + " amp\n", + " ()\n", + " sx\n", + " 0.250000+0.000000j\n", + " default\n", " True\n", + " 2021-10-21 13:36:26.085049+0200\n", " None\n", - " default\n", - " ()\n", - " amp\n", - " x\n", " \n", " \n", " 1\n", - " 0.250000+0.000000j\n", - " 2021-07-30 17:53:14.422995+0000\n", + " amp\n", + " ()\n", + " x\n", + " 0.500000+0.000000j\n", + " default\n", " True\n", + " 2021-10-21 13:36:26.085021+0200\n", " None\n", - " default\n", - " ()\n", - " amp\n", - " sx\n", " \n", " \n", " 2\n", - " 0.786215+0.000000j\n", - " 2021-07-31 02:56:07.570000+0900\n", - " True\n", - " fb23c9c4-1ef9-4c69-a623-0ff4dad4a956\n", - " default\n", - " (0,)\n", " amp\n", + " ()\n", " x\n", + " 0.500000+0.000000j\n", + " default\n", + " True\n", + " 2021-09-03 18:16:11.793776+0200\n", + " \n", " \n", " \n", " 3\n", - " 0.393107+0.000000j\n", - " 2021-07-31 02:56:07.570000+0900\n", - " True\n", - " fb23c9c4-1ef9-4c69-a623-0ff4dad4a956\n", - " default\n", + " amp\n", " (0,)\n", + " sx\n", + " 0.397121+0.000000j\n", + " default\n", + " True\n", + " 2021-09-03 18:18:42.082000+0200\n", + " 7e6b27d5-c5a8-4477-a4a2-8c6a5fdb9be0\n", + " \n", + " \n", + " 4\n", " amp\n", + " (0,)\n", " sx\n", + " 0.429931+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 13:46:27.501000+0200\n", + " 5fb59cde-c1ec-4725-b1c4-fea7836f5463\n", + " \n", + " \n", + " 5\n", + " amp\n", + " (0,)\n", + " x\n", + " 0.859863+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 13:46:27.501000+0200\n", + " 5fb59cde-c1ec-4725-b1c4-fea7836f5463\n", " \n", " \n", "\n", "" ], "text/plain": [ - " value date_time valid \\\n", - "0 0.500000+0.000000j 2021-07-30 17:53:14.422975+0000 True \n", - "1 0.250000+0.000000j 2021-07-30 17:53:14.422995+0000 True \n", - "2 0.786215+0.000000j 2021-07-31 02:56:07.570000+0900 True \n", - "3 0.393107+0.000000j 2021-07-31 02:56:07.570000+0900 True \n", + " parameter qubits schedule value group valid \\\n", + "0 amp () sx 0.250000+0.000000j default True \n", + "1 amp () x 0.500000+0.000000j default True \n", + "2 amp () x 0.500000+0.000000j default True \n", + "3 amp (0,) sx 0.397121+0.000000j default True \n", + "4 amp (0,) sx 0.429931+0.000000j default True \n", + "5 amp (0,) x 0.859863+0.000000j default True \n", "\n", - " exp_id group qubits parameter schedule \n", - "0 None default () amp x \n", - "1 None default () amp sx \n", - "2 fb23c9c4-1ef9-4c69-a623-0ff4dad4a956 default (0,) amp x \n", - "3 fb23c9c4-1ef9-4c69-a623-0ff4dad4a956 default (0,) amp sx " + " date_time exp_id \n", + "0 2021-10-21 13:36:26.085049+0200 None \n", + "1 2021-10-21 13:36:26.085021+0200 None \n", + "2 2021-09-03 18:16:11.793776+0200 \n", + "3 2021-09-03 18:18:42.082000+0200 7e6b27d5-c5a8-4477-a4a2-8c6a5fdb9be0 \n", + "4 2021-10-21 13:46:27.501000+0200 5fb59cde-c1ec-4725-b1c4-fea7836f5463 \n", + "5 2021-10-21 13:46:27.501000+0200 5fb59cde-c1ec-4725-b1c4-fea7836f5463 " ] }, - "execution_count": 25, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -824,6 +834,7 @@ }, { "cell_type": "markdown", + "id": "c90b2be5", "metadata": {}, "source": [ "The table above shows that we have now updated the amplitude of our $\\pi$-pulse from 0.5 to the value obtained in the most recent Rabi experiment. Importantly, since we linked the amplitudes of the `x` and `y` schedules we will see that the amplitude of the `y` schedule has also been updated as seen when requesting schedules form the `Calibrations` instance. Furthermore, we used the result from the `Rabi` experiment to also update the value of the `sx` pulse. This was achieved by specifying `(np.pi/2, \"amp\", \"sx\")` when calling `update`." @@ -831,16 +842,17 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 33, + "id": "bd9ff343", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=(0.39310742+0j), sigma=80, beta=0), DriveChannel(0)), name=\"sx\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=(0.42993129+0j), sigma=80, beta=0), DriveChannel(0)), name=\"sx\", transform=AlignLeft())" ] }, - "execution_count": 26, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -851,16 +863,17 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 34, + "id": "95d75c23", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=(0.78621484+0j), sigma=80, beta=0), DriveChannel(0)), name=\"x\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=(0.85986258+0j), sigma=80, beta=0), DriveChannel(0)), name=\"x\", transform=AlignLeft())" ] }, - "execution_count": 27, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -871,16 +884,17 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 35, + "id": "62b1318f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=0.78621484j, sigma=80, beta=0), DriveChannel(0)), name=\"y\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=0.85986258j, sigma=80, beta=0), DriveChannel(0)), name=\"y\", transform=AlignLeft())" ] }, - "execution_count": 28, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -891,6 +905,7 @@ }, { "cell_type": "markdown", + "id": "addeda59", "metadata": {}, "source": [ "## 3. Saving and loading calibrations\n", @@ -900,14 +915,15 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 36, + "id": "317994db", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/knzwnao/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/calibrations.py:937: UserWarning: Schedules are only saved in text format. They cannot be re-loaded.\n", + "/home/daniel/Documents/IBM/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/calibrations.py:981: UserWarning: Schedules are only saved in text format. They cannot be re-loaded.\n", " warnings.warn(\"Schedules are only saved in text format. They cannot be re-loaded.\")\n" ] } @@ -918,6 +934,7 @@ }, { "cell_type": "markdown", + "id": "b384d6d0", "metadata": {}, "source": [ "After saving the values of the parameters you may restart your kernel. If you do so, you will only need to run the following cell to recover the state of your calibrations. Since the schedules are currently not stored we need to call our `setup_cals` function to populate an instance of `Calibrations` with the template schedules. By contrast, the value of the parameters will be recovered from the file." @@ -925,9 +942,25 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 37, + "id": "24256b82", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "CalibrationError", + "evalue": "'No parameter for meas_lo_freq and schedule and qubits (0,). No default value exists.'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mCalibrationError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/tmp/ipykernel_22982/2476373101.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mcals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBackendCalibrations\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlibrary\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mcals\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_parameter_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Armonkparameter_values.csv\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Documents/IBM/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/calibrations.py\u001b[0m in \u001b[0;36mload_parameter_values\u001b[0;34m(self, file_name)\u001b[0m\n\u001b[1;32m 1065\u001b[0m )\n\u001b[1;32m 1066\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParameterKey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"parameter\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_to_tuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"qubits\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrow\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"schedule\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1067\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_parameter_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparam_val\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1068\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1069\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mclassmethod\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/IBM/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/backend_calibrations.py\u001b[0m in \u001b[0;36madd_parameter_value\u001b[0;34m(self, value, param, qubits, schedule)\u001b[0m\n\u001b[1;32m 392\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mschedule\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[0mschedule\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mschedule\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mschedule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mScheduleBlock\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mschedule\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 394\u001b[0;31m \u001b[0mparam_obj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalibration_parameter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparam\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqubits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mschedule\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 395\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parameter_inst_map_update\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparam_obj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Documents/IBM/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/calibrations.py\u001b[0m in \u001b[0;36mcalibration_parameter\u001b[0;34m(self, parameter_name, qubits, schedule_name)\u001b[0m\n\u001b[1;32m 382\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parameter_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mParameterKey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparameter_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mschedule_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 383\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 384\u001b[0;31m raise CalibrationError(\n\u001b[0m\u001b[1;32m 385\u001b[0m \u001b[0;34mf\"No parameter for {parameter_name} and schedule {schedule_name} \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 386\u001b[0m \u001b[0;34mf\"and qubits {qubits}. No default value exists.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mCalibrationError\u001b[0m: 'No parameter for meas_lo_freq and schedule and qubits (0,). No default value exists.'" + ] + } + ], "source": [ "cals = BackendCalibrations(backend, library)\n", "cals.load_parameter_values(file_name=\"Armonkparameter_values.csv\")" @@ -936,6 +969,7 @@ { "cell_type": "code", "execution_count": 31, + "id": "80ca665c", "metadata": {}, "outputs": [ { @@ -1069,6 +1103,7 @@ }, { "cell_type": "markdown", + "id": "7d1f127f", "metadata": {}, "source": [ "## 4. Calibrating the value of the DRAG coefficient\n", @@ -1092,6 +1127,7 @@ { "cell_type": "code", "execution_count": 32, + "id": "74edd0ee", "metadata": {}, "outputs": [], "source": [ @@ -1102,6 +1138,7 @@ { "cell_type": "code", "execution_count": 33, + "id": "fac11c93", "metadata": {}, "outputs": [], "source": [ @@ -1111,6 +1148,7 @@ { "cell_type": "code", "execution_count": 34, + "id": "3a337cf4", "metadata": {}, "outputs": [ { @@ -1138,6 +1176,7 @@ { "cell_type": "code", "execution_count": 35, + "id": "c3958dff", "metadata": {}, "outputs": [ { @@ -1159,6 +1198,7 @@ { "cell_type": "code", "execution_count": 36, + "id": "3a6430f4", "metadata": {}, "outputs": [ { @@ -1180,6 +1220,7 @@ { "cell_type": "code", "execution_count": 37, + "id": "dc39db70", "metadata": {}, "outputs": [ { @@ -1203,6 +1244,7 @@ { "cell_type": "code", "execution_count": 38, + "id": "df67fefe", "metadata": {}, "outputs": [], "source": [ @@ -1212,6 +1254,7 @@ { "cell_type": "code", "execution_count": 39, + "id": "f02bd7a6", "metadata": {}, "outputs": [ { @@ -1332,6 +1375,7 @@ }, { "cell_type": "markdown", + "id": "00ae061c", "metadata": {}, "source": [ "## 5. Fine amplitude calibration\n", @@ -1344,37 +1388,38 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 19, + "id": "20ab91f2", "metadata": {}, "outputs": [], "source": [ - "from qiskit_experiments.library.calibration.fine_amplitude import FineXAmplitude\n", - "from qiskit_experiments.calibration_management.update_library import Amplitude" + "from qiskit_experiments.library.calibration.fine_amplitude import FineXAmplitudeCal" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 23, + "id": "bfb3124b", "metadata": {}, "outputs": [], "source": [ - "amp_x_cal = FineXAmplitude(qubit)\n", - "amp_x_cal.set_experiment_options(schedule=cals.get_schedule(\"x\", qubit))" + "amp_x_cal = FineXAmplitudeCal(qubit, cals, schedule_name=\"x\")" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 24, + "id": "c6127e65", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAB7CAYAAAA7U/R7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAARH0lEQVR4nO3deVQUZ6IF8Ns0Cgi4gYKIRhEVBBEQjRplURM8ovKOLKMPfZNEYoIQxQVXFOQF4rj7jMuYqBm3jKCGlxMlARfII0RH3AB3nDCAxygQdxFtut8fxh4bEBp6qer2/v5qq7+qus1BLl9RX7dEoVAoQEREJDAToQMQEREBLCQiIhIJFhIREYkCC4mIiESBhURERKLAQiIiIlFgIRERkSiwkIiISBRYSEREJAosJCIiEgUWEhERiQILiYiIRIGFREREosBCIiIiUWAhERGRKLCQiIhIFFhIREQkCiwkIiISBRYSERGJgqnQAYiIxOzKlStNjvniiy8QExPT6BgXFxdtRTJanCEREWlo06ZNQkcwCiwkIiISBRYSERGJAguJiEhDBw4cEDqCUWAhERGRKLCQiIg0FBoaKnQEo8DbvgV0KB+4eVeYc3ftAEz0adm+c69ewoWHD7UbSA0DrK2xpm+/Fu0rVGag5bkNMTNgmN8fhio2Nhbnz5/X+3k9PT2xfv16rR+XhSSgm3eBG3eETtF8Fx4+xE93fxc6RrMws/4Yam5DdP78eeTk5AgdQ2t4yY6ISEPR0dFCRzAKLCQiIg019S4NpB4WEhGRhnx9fYWOYBRYSEREGqqoqBA6glFgIRERkSiwkIiINNSv35t1u7musJCIiDR08OBBoSPojKWlJUxN9bNCiOuQDMjzp49xZGM4Si4cadH+s/YotJyIiABg2bJlSEpKEjpGozp06ICQkBAMHjwY/fv3h6WlJWpqanD16lXk5+cjPT0dJSUlKvtYWloiIyMDt2/fxuTJkyGTyXSakYVkQIpPH0Tvt8MQHHdY6ChE9Iq0tDTRFlLnzp2RnJyMiIgIWFhY1Hvex8cHERERWLNmDQ4fPozFixejqKhIWUYjRoxAWVkZ7OzscPPmTZ1m5SW7BsjlcqxevRq9e/eGubk5BgwYgJycHPTt2xfTp08XLFdx/iE4D37xnlm1smfYu9gTP+2dqzLm3A8bsGPWW6h5fE+AhEQkJiEhIbh06RIiIyNhYWGBH3/8EbGxsfDz84OHhweGDh2K6dOnY9++fXj+/DnGjx+PM2fOICEhQaWMAgICdF5GAGdIDZo2bRoOHTqEpUuXYuDAgcjLy8PkyZNRUVGBOXPmCJLp0e83YdamA1qbWwEApKatMWbGXvw9YTB6egahm9tIVJYVIi9tMYLnHYGZZXtBchKROMyYMUP5SbaZmZmIiYnB9evX6407efIkvvzyS8yaNQtJSUmIiopCYmIiACjL6MaNG3rJzBlSHd988w2+/vprfPfdd5g3bx4CAgKwZMkSDB06FDKZDN7e3nrJ8ezpIzyr/vcbVF7N2weXd6aojLFxdMOwsBRkbnsfj+/9hh82R2DAuzFwdPXTS0Z1Kap+x/Pw/4T86HHlNtma9ZDFLYSitlbAZK9niJkBw8xtiJnrEtv7yU2YMEFZRnFxcQgMDGywjF5VWVmJuLg4FBUVKbelp6frrYwAFlI9KSkpGDNmDPz8VH+oOzs7o1WrVvDw8NB5hl/PHUZa0nAUHtuq3FZ+ORvd+gXUG+sZOBMdHVyxd7EHTExMMTT0v3Wer7kkNh0hXRiH2i82Q1FaCnnWMSj+cRrSRfMhkUqFjtcgQ8wMGGZuQ8xc18WLF4WOoGRjY4Nt27YBABYuXIjVq1ertd/Lvxm5u7ujoqICcrkcUVFRGDhwoC7jquAlu1eUl5ejqKgIs2fPrvdcaWkp3NzcYGZm1uRxJBKJWucLWXICjq7+9bb39AqC7NkT/ON/P8PAcXGo+Nd5dHrLExKT+r8/SCQSOLr6o7QwEz7jF0Fq2lqtc+fkZGPme/ULTh3SVStgMqB5xWzi7QXFxP+ALCEJuHsX0oSlkHTs2KxjZGdnQzJoSLP2eUmozEDLc7ckM/Dmfq01ydyYhn4e1LVu3bomx61bt05bkRoVHx8POzs7ZGdnY+XKlWrtU/cGhoCAAMyYMQNz5szB+vXrMWLECJXxOTk5av+cAwCFQr07fDlDekV5eTkAwN7eXmV7dXU1cnJy9Ha5DgB6eo3Hg8p/oaK0AJdzd8N1xJ8bHFdZVvhHcS3AqW+X40Flqd4yNpfJuLHAnTuQ9OoFEy9PoeOoxRAzA4aZ2xAzi02bNm3w/vvvA3hRpOoUQUNldOPGDSxbtgz379/H8OHD9XJlCOAMSYWtrS0A4Nq1axg7dqxy+8qVK3Hr1i21p67q/jawMev1n4dk2toczoNCcPn//oYHd/6JDl361Bsje16DHzZHwCswFsPCk/Hk/m1k/fXPmLjoWIOzqVf5+fnjwGctW5c0Ov9Usz/vRiGXo3blGkjeHgzFpSuQ/5AJkzHvNesY/v7+OKrm17YuoTIDLc/dkszAm/u11iRzY65cudLkmHXr1jV5B+7atWu1FUnJ399f5e9XY8aMQfv27XHy5Em1PrjvdWUEAI8fP8bu3bsRExODSZMmoaCgQLmfn58fsrOztf1yOEN6lZOTEzw8PJCSkoJdu3bh2LFjiIqKwo4dOwBAr9dSAcDlnSm4kLkR3fs3/B8zb/+LS3RvT0wEAPj/1//gQWUJzmZo/xtfU/J9f4eishLSuHmQLl6A2q1/heLXEqFjNcoQMwOGmdsQM79q+fLlQkcA8GJNEQBkZWU1ObaxMnrp6NGjKsfVNRbSK0xMTJCWlgY3NzdERUXhgw8+gK2tLaKjoyGVSvU2bX3J0dUf1rZvoc/QSfWeKy06hqIT2zAmai+kpq0AAK0trPHeJ7tx8lACKssK9Zq1MfJz5yE/cBCm8YshsTCHiUd/mISFQvbZ51BUPxU6XoMMMTNgmLkNMXNd4eHhQkcAALi5uQEALly40Og4dcoIgHKW9fK4usZLdnX06dMHJ06cUNk2depU9OvXr8FVzrokkUgQFv8TzC071Huuu/sozNj+qN72rn2HI3r7Y33EU5uJlydM0lXf60saMRnSiMkCJWqaIWYGDDO3IWauy9XVFZcvXxY6BlJTU1FQUKByea0hycnJTZYRANy5cwcpKSm4d++eDtLWx0JSQ35+PoYM0f7dO+qw7NBFkPMSkeHZu3evWuOWLl0KBwcHLFq0qNF1RtXV1ViyZIm24jWJl+ya8OjRI1y7dk2vd9gREenSw4cPER4ertdFr+rgDKkJVlZWqDWQ1eJEJAx/f3+hIxgFzpCIiDS0ZcsWoSMYBRYSEZGGoqKihI5gFFhIREQa0sUi0TcRC4mIiESBhURERKLAQiIi0pAYFsUaAxYSEZGGUlNThY5gFLgOSUBd678jkEGce4C1tfaC6Om8QmXW5NyGmFnTfTUh5NcrISFBkPez8/T0bPY+/yy9BQBw6t5F5bGuz6sOiULdz0ogInoDqfPxE+q8l52Li4u2Imlk4V9efJrsigXTVR6LAS/ZERGRKLCQiIg0tHnzZqEjGAUWEhGRhvT1eUHGjoVERKQhPz8/oSMYBRYSERGJAguJiIhEgeuQiIgaoc7t2gkJCaK5rduQcYZERKShxMREoSMYBRYSERGJAguJiIhEgYVERESiwEIiIiJRYCEREZEosJCIiEgUWEh6NmvWLDg6OsLUlEvAiMjwZGdnw83NDc7OzoiMjERtba3Wjs1C0rOwsDDk5+cLHYOIqNnkcjkiIyORlpaG4uJiPHjwAHv27NHa8VlIejZ8+HDY29sLHYOIqNlOnz4NBwcH9OvXDwAwbdo0HDx4UGvHZyEREZFaysvL0a1bN+W/u3fvjrKyMq0dn3/IICIyYk+qn+JvB3/Es+cyle0bdh5s8HHYWD842Nk2eCyFQqGbkH/gDImIyIi1sTCHt3sf3LpThVt3qpTb6z6+dacK3bp0em0ZAUC3bt1UZkSlpaVwdHTUWlYWEhGRkRs8wAUuvbo3OqZje2sEjRza6BgfHx+Ul5fj0qVLAIDt27dj4sSJWsvJQtKzjz/+GI6OjqitrYWjoyOio6OFjkRERk4ikSBkjC/aWJi99vk/BQXArHWrRo8jlUrx1VdfITQ0FL169YKVlRWmTp2qvZwKXV8UJLUpFApIJBKhYxCRkSq6+iv2pGfV2x4w1BOBvoMFSKSKMyQRSc/MxXdHfxY6BhEZKfe+PeHt3kdlm4OdDUa9M1CgRKpYSCJRde8BThdcAcAZEhHpzoTRw9C+rRUAwFQqxZ+CAmAqlQqc6gXRFFJiYiIkEgmKiooQFBQEKysrdOnSBatWrQIAZGRkwNvbG23atIGXlxdyc3NV9s/Ly0NgYCDatWsHCwsLjBgxot6Y/Px8hIeHo3v37rCwsICzszM+/fRT3L9/X2VccXExQkNDYW9vDzMzM3Tt2hUTJkxAVVUVdOXEL+dgIjGB/9sDdHYOIiJzs9YIC/KHBECg3yDYdeoodCQl0a1DCgsLQ2RkJGbPno1du3Zh/vz5qKqqwvfff4/4+HhYW1tjyZIlCA4ORklJCaytrZGZmYlx48Zh5MiR2LlzJ8zMzLBp0yaMGjUKubm5GDRoEACgpKQE/fv3x5QpU9CuXTsUFxfj888/x9mzZ/Hzz/++VBYUFIS2bdti48aNsLOzw2+//YasrCxUV1er9RoW/mVbi19/yua9Ld6XiKg5Dh8/icPHT+r8PCsWTFdrnGhuakhMTMTy5cuxZcsWfPLJJwCAmpoa2NnZ4cmTJ7h27Rp69OgBADh+/DhGjRqFAwcOICQkBH369IGtrS1yc3NhYvJi0ieTyeDu7g4nJyccOXKkwXPKZDL88ssv8PX1xblz5+Dp6YnKykp06tQJ6enpCA4ObtFr0aSQiIiMjbqFJLoZ0tixY5WPzczM4OTkhNraWmUZAYCLiwsAoKysDMXFxbh+/TpiY2Mhl8shl8uV40aPHo2dO3cq//3o0SOsWLEC+/fvR1lZGWpqapTPXb16FZ6enrCxsYGTkxMWLlyI27dvw9fXV3k+dan7xQde/O1ozZf7McTLDRNGD2vWeYiIjInoCqljR9Xrma1bt4a5uXm9bQDw9OlT3L59GwAQHR392jU91dXVsLCwwIcffoiMjAwkJibC29sb1tbWKCsrw8SJE5WX4yQSCY4ePYqkpCTEx8ejoqJCuV5owYIFat2W3ZIZUt6ZIuSdKWr2fkREYmewM6TmsrGxAfDikl9QUFCDY8zMzPD06VN8++23WLZsGebOnat8ru4NDQDQs2dP7Ny5EwqFAhcvXsSOHTuwaNEi2NraIjIyUjcvhIjoDWfwhdS3b184OTmhsLAQCQkJrx1XU1MDmUyGVq1UVyLv2LHjtftIJBK4u7tj7dq12Lp1KwoLC9XKpO5vAwcycnD+YjHmfzwJba0t1dqHiMhYGXwhSSQSbN26FUFBQQgODsaUKVPQuXNnVFRU4OzZs3j+/DlWrVqFdu3aYdiwYVi9ejXs7Ozg4OCA1NRUnDp1SuV4BQUFmDlzJsLDw9G7d28AQFpaGqqrqxEYGKi13FX3HuBs0TUM8XJjGRERwQgKCQDeffdd5OXlITk5GVFRUXj48CE6d+4Mb29vfPTRR8px+/btQ0xMDGJjYyGVSjFu3Djs378fPj4+yjH29vbo0aMHNmzYgPLycrRq1Qqurq5ITU1VueFCU7/ffYC2VpZcd0RE9AfR3Pb9JpLL5crb1ImI3nQsJCIiEgX+ek5ERKLAQiIiIlFgIRERkSiwkIiISBRYSEREJAosJCIiEgUWEhERiQILiYiIRIGFREREosBCIiIiUWAhERGRKLCQiIhIFFhIREQkCiwkIiISBRYSERGJAguJiIhEgYVERESiwEIiIiJRYCEREZEosJCIiEgUWEhERCQKLCQiIhIFFhIREYkCC4mIiESBhURERKLAQiIiIlFgIRERkSj8Pzs/HdZKfTvWAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, - "execution_count": 42, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1386,6 +1431,7 @@ { "cell_type": "code", "execution_count": 43, + "id": "24067164", "metadata": {}, "outputs": [ { @@ -1400,13 +1446,13 @@ } ], "source": [ - "data_fine = amp_x_cal.run(backend)\n", - "data_fine.block_for_results()" + "data_fine = amp_x_cal.run(backend).block_for_results()" ] }, { "cell_type": "code", "execution_count": 44, + "id": "076bed0c", "metadata": {}, "outputs": [ { @@ -1428,6 +1474,7 @@ { "cell_type": "code", "execution_count": 45, + "id": "cf2cc09a", "metadata": {}, "outputs": [ { @@ -1450,6 +1497,7 @@ }, { "cell_type": "markdown", + "id": "367c2e1f", "metadata": {}, "source": [ "The cell below shows how the amplitude is updated based on the error in the rotation angle measured by the `FineXAmplitude` experiment. Note that this calculation is automatically done by the `Amplitude.update` function." @@ -1458,6 +1506,7 @@ { "cell_type": "code", "execution_count": 46, + "id": "81adf659", "metadata": {}, "outputs": [ { @@ -1481,6 +1530,7 @@ { "cell_type": "code", "execution_count": 47, + "id": "f15bbb4d", "metadata": {}, "outputs": [], "source": [ @@ -1490,6 +1540,7 @@ { "cell_type": "code", "execution_count": 48, + "id": "81e7f3de", "metadata": {}, "outputs": [ { @@ -1636,6 +1687,7 @@ }, { "cell_type": "markdown", + "id": "114a92a9", "metadata": {}, "source": [ "To check that we have managed to reduce the error in the rotation angle we will run the fine amplitude calibration experiment once again." @@ -1644,6 +1696,7 @@ { "cell_type": "code", "execution_count": 49, + "id": "5f1f9c3c", "metadata": {}, "outputs": [], "source": [ @@ -1653,6 +1706,7 @@ { "cell_type": "code", "execution_count": 50, + "id": "84146c1a", "metadata": {}, "outputs": [ { @@ -1674,6 +1728,7 @@ { "cell_type": "code", "execution_count": 51, + "id": "5218f8e0", "metadata": {}, "outputs": [ { @@ -1694,6 +1749,7 @@ }, { "cell_type": "markdown", + "id": "2fbc466a", "metadata": {}, "source": [ "As can be seen from the data above and the analysis result below we have managed to reduce the error in the rotation angle ${\\rm d}\\theta$." @@ -1702,6 +1758,7 @@ { "cell_type": "code", "execution_count": 52, + "id": "25ddccd3", "metadata": {}, "outputs": [ { @@ -1724,6 +1781,7 @@ }, { "cell_type": "markdown", + "id": "a4935730", "metadata": {}, "source": [ "### Fine amplitude calibration of the $\\pi/2$ rotation\n", @@ -1734,6 +1792,7 @@ { "cell_type": "code", "execution_count": 53, + "id": "50423105", "metadata": {}, "outputs": [], "source": [ @@ -1743,6 +1802,7 @@ { "cell_type": "code", "execution_count": 55, + "id": "a075eacb", "metadata": {}, "outputs": [], "source": [ @@ -1753,6 +1813,7 @@ { "cell_type": "code", "execution_count": 56, + "id": "3d38a13f", "metadata": {}, "outputs": [ { @@ -1774,6 +1835,7 @@ { "cell_type": "code", "execution_count": 57, + "id": "6c00c3f5", "metadata": {}, "outputs": [ { @@ -1795,6 +1857,7 @@ { "cell_type": "code", "execution_count": 58, + "id": "0117cb2d", "metadata": {}, "outputs": [ { @@ -1816,6 +1879,7 @@ { "cell_type": "code", "execution_count": 59, + "id": "5d5a1131", "metadata": {}, "outputs": [ { @@ -1839,6 +1903,7 @@ { "cell_type": "code", "execution_count": 60, + "id": "b1dc7486", "metadata": {}, "outputs": [], "source": [ @@ -1848,6 +1913,7 @@ { "cell_type": "code", "execution_count": 61, + "id": "ae984c47", "metadata": {}, "outputs": [ { @@ -2008,6 +2074,7 @@ { "cell_type": "code", "execution_count": 62, + "id": "f7cb5878", "metadata": {}, "outputs": [ { @@ -2028,6 +2095,7 @@ { "cell_type": "code", "execution_count": 63, + "id": "f45f6482", "metadata": {}, "outputs": [ { @@ -2048,6 +2116,7 @@ { "cell_type": "code", "execution_count": 64, + "id": "68f6e469", "metadata": {}, "outputs": [ { @@ -2068,6 +2137,7 @@ { "cell_type": "code", "execution_count": 65, + "id": "8c8369d4", "metadata": {}, "outputs": [ { @@ -2091,6 +2161,7 @@ { "cell_type": "code", "execution_count": null, + "id": "1ef7ec55", "metadata": {}, "outputs": [], "source": [] @@ -2098,7 +2169,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2112,7 +2183,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.0" + "version": "3.8.5" } }, "nbformat": 4, From a1df97cf40608c8ea05dab48089115878576787e Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 21 Oct 2021 14:49:00 +0200 Subject: [PATCH 07/19] * Updated the tutorial. --- docs/tutorials/calibrating_armonk.ipynb | 884 ++++++++---------- .../calibration_management/calibrations.py | 8 +- 2 files changed, 410 insertions(+), 482 deletions(-) diff --git a/docs/tutorials/calibrating_armonk.ipynb b/docs/tutorials/calibrating_armonk.ipynb index 712d114fec..db4e77529d 100644 --- a/docs/tutorials/calibrating_armonk.ipynb +++ b/docs/tutorials/calibrating_armonk.ipynb @@ -165,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "908ff764", "metadata": {}, "outputs": [], @@ -221,112 +221,112 @@ " \n", " \n", " 0\n", - " σ\n", + " β\n", " ()\n", - " x\n", - " 8.000000e+01\n", + " sx\n", + " 0.000000e+00\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997950+0200\n", + " 2021-10-21 14:21:13.496348+0200\n", " None\n", " \n", " \n", " 1\n", - " amp\n", + " σ\n", " ()\n", - " x\n", - " 5.000000e-01\n", + " sx\n", + " 8.000000e+01\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997896+0200\n", + " 2021-10-21 14:21:13.496341+0200\n", " None\n", " \n", " \n", " 2\n", - " meas_lo_freq\n", - " (0,)\n", - " None\n", - " 6.993371e+09\n", + " amp\n", + " ()\n", + " sx\n", + " 2.500000e-01\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997584+0200\n", + " 2021-10-21 14:21:13.496333+0200\n", " None\n", " \n", " \n", " 3\n", - " β\n", + " duration\n", " ()\n", " sx\n", - " 0.000000e+00\n", + " 3.200000e+02\n", " default\n", " True\n", - " 2021-10-21 13:31:28.998004+0200\n", + " 2021-10-21 14:21:13.496325+0200\n", " None\n", " \n", " \n", " 4\n", - " duration\n", - " ()\n", - " sx\n", - " 3.200000e+02\n", + " qubit_lo_freq\n", + " (0,)\n", + " None\n", + " 4.971593e+09\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997996+0200\n", + " 2021-10-21 14:21:13.495991+0200\n", " None\n", " \n", " \n", " 5\n", - " duration\n", - " ()\n", - " x\n", - " 3.200000e+02\n", + " meas_lo_freq\n", + " (0,)\n", + " None\n", + " 6.993371e+09\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997932+0200\n", + " 2021-10-21 14:21:13.496017+0200\n", " None\n", " \n", " \n", " 6\n", - " σ\n", + " β\n", " ()\n", - " sx\n", - " 8.000000e+01\n", + " x\n", + " 0.000000e+00\n", " default\n", " True\n", - " 2021-10-21 13:31:28.998011+0200\n", + " 2021-10-21 14:21:13.496317+0200\n", " None\n", " \n", " \n", " 7\n", - " qubit_lo_freq\n", - " (0,)\n", - " None\n", - " 4.971593e+09\n", + " σ\n", + " ()\n", + " x\n", + " 8.000000e+01\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997535+0200\n", + " 2021-10-21 14:21:13.496309+0200\n", " None\n", " \n", " \n", " 8\n", " amp\n", " ()\n", - " sx\n", - " 2.500000e-01\n", + " x\n", + " 5.000000e-01\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997983+0200\n", + " 2021-10-21 14:21:13.496299+0200\n", " None\n", " \n", " \n", " 9\n", - " β\n", + " duration\n", " ()\n", " x\n", - " 0.000000e+00\n", + " 3.200000e+02\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997875+0200\n", + " 2021-10-21 14:21:13.496281+0200\n", " None\n", " \n", " \n", @@ -335,28 +335,28 @@ ], "text/plain": [ " parameter qubits schedule value group valid \\\n", - "0 σ () x 8.000000e+01 default True \n", - "1 amp () x 5.000000e-01 default True \n", - "2 meas_lo_freq (0,) None 6.993371e+09 default True \n", - "3 β () sx 0.000000e+00 default True \n", - "4 duration () sx 3.200000e+02 default True \n", - "5 duration () x 3.200000e+02 default True \n", - "6 σ () sx 8.000000e+01 default True \n", - "7 qubit_lo_freq (0,) None 4.971593e+09 default True \n", - "8 amp () sx 2.500000e-01 default True \n", - "9 β () x 0.000000e+00 default True \n", + "0 β () sx 0.000000e+00 default True \n", + "1 σ () sx 8.000000e+01 default True \n", + "2 amp () sx 2.500000e-01 default True \n", + "3 duration () sx 3.200000e+02 default True \n", + "4 qubit_lo_freq (0,) None 4.971593e+09 default True \n", + "5 meas_lo_freq (0,) None 6.993371e+09 default True \n", + "6 β () x 0.000000e+00 default True \n", + "7 σ () x 8.000000e+01 default True \n", + "8 amp () x 5.000000e-01 default True \n", + "9 duration () x 3.200000e+02 default True \n", "\n", " date_time exp_id \n", - "0 2021-10-21 13:31:28.997950+0200 None \n", - "1 2021-10-21 13:31:28.997896+0200 None \n", - "2 2021-10-21 13:31:28.997584+0200 None \n", - "3 2021-10-21 13:31:28.998004+0200 None \n", - "4 2021-10-21 13:31:28.997996+0200 None \n", - "5 2021-10-21 13:31:28.997932+0200 None \n", - "6 2021-10-21 13:31:28.998011+0200 None \n", - "7 2021-10-21 13:31:28.997535+0200 None \n", - "8 2021-10-21 13:31:28.997983+0200 None \n", - "9 2021-10-21 13:31:28.997875+0200 None " + "0 2021-10-21 14:21:13.496348+0200 None \n", + "1 2021-10-21 14:21:13.496341+0200 None \n", + "2 2021-10-21 14:21:13.496333+0200 None \n", + "3 2021-10-21 14:21:13.496325+0200 None \n", + "4 2021-10-21 14:21:13.495991+0200 None \n", + "5 2021-10-21 14:21:13.496017+0200 None \n", + "6 2021-10-21 14:21:13.496317+0200 None \n", + "7 2021-10-21 14:21:13.496309+0200 None \n", + "8 2021-10-21 14:21:13.496299+0200 None \n", + "9 2021-10-21 14:21:13.496281+0200 None " ] }, "execution_count": 9, @@ -372,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "502aef29", "metadata": {}, "outputs": [], @@ -385,7 +385,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "91184061", "metadata": {}, "outputs": [ @@ -396,7 +396,7 @@ "
" ] }, - "execution_count": 13, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -408,7 +408,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "32a49399", "metadata": {}, "outputs": [ @@ -419,7 +419,7 @@ "
" ] }, - "execution_count": 14, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -430,7 +430,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "1e24ce2a", "metadata": {}, "outputs": [], @@ -440,18 +440,18 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "id": "e880af97", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 16, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -462,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "id": "6e8e067c", "metadata": {}, "outputs": [ @@ -472,8 +472,8 @@ "text": [ "DbAnalysisResultV1\n", "- name: f01\n", - "- value: 4971653459.195527 ± 50071.2409732263 Hz\n", - "- χ²: 0.7294501888302608\n", + "- value: 4971617198.1562395 ± 48877.278375288435 Hz\n", + "- χ²: 1.2265631671328414\n", "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" @@ -494,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "id": "6937956d", "metadata": {}, "outputs": [ @@ -532,13 +532,13 @@ " \n", " \n", " 0\n", - " qubit_lo_freq\n", + " meas_lo_freq\n", " (0,)\n", " None\n", - " 4.971593e+09\n", + " 6.993371e+09\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997535+0200\n", + " 2021-10-21 14:21:13.496017+0200\n", " None\n", " \n", " \n", @@ -546,22 +546,22 @@ " qubit_lo_freq\n", " (0,)\n", " None\n", - " 4.971653e+09\n", + " 4.971593e+09\n", " default\n", " True\n", - " 2021-10-21 13:34:22.222000+0200\n", - " 3830f027-b9a7-40d9-9c3b-e79c817a3de3\n", + " 2021-10-21 14:21:13.495991+0200\n", + " None\n", " \n", " \n", " 2\n", - " meas_lo_freq\n", + " qubit_lo_freq\n", " (0,)\n", " None\n", - " 6.993371e+09\n", + " 4.971617e+09\n", " default\n", " True\n", - " 2021-10-21 13:31:28.997584+0200\n", - " None\n", + " 2021-10-21 14:26:42.953000+0200\n", + " 553c95bf-e578-4064-9b17-68a07b84a7f0\n", " \n", " \n", "\n", @@ -569,17 +569,17 @@ ], "text/plain": [ " parameter qubits schedule value group valid \\\n", - "0 qubit_lo_freq (0,) None 4.971593e+09 default True \n", - "1 qubit_lo_freq (0,) None 4.971653e+09 default True \n", - "2 meas_lo_freq (0,) None 6.993371e+09 default True \n", + "0 meas_lo_freq (0,) None 6.993371e+09 default True \n", + "1 qubit_lo_freq (0,) None 4.971593e+09 default True \n", + "2 qubit_lo_freq (0,) None 4.971617e+09 default True \n", "\n", " date_time exp_id \n", - "0 2021-10-21 13:31:28.997535+0200 None \n", - "1 2021-10-21 13:34:22.222000+0200 3830f027-b9a7-40d9-9c3b-e79c817a3de3 \n", - "2 2021-10-21 13:31:28.997584+0200 None " + "0 2021-10-21 14:21:13.496017+0200 None \n", + "1 2021-10-21 14:21:13.495991+0200 None \n", + "2 2021-10-21 14:26:42.953000+0200 553c95bf-e578-4064-9b17-68a07b84a7f0 " ] }, - "execution_count": 18, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -608,7 +608,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 17, "id": "ed4a5f77", "metadata": {}, "outputs": [], @@ -619,7 +619,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 18, "id": "8227b8ba", "metadata": {}, "outputs": [], @@ -633,7 +633,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 19, "id": "68d32b29", "metadata": {}, "outputs": [], @@ -643,18 +643,18 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 20, "id": "9eefc00c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 29, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -665,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 21, "id": "444d829c", "metadata": {}, "outputs": [ @@ -675,8 +675,8 @@ "text": [ "DbAnalysisResultV1\n", "- name: rabi_rate\n", - "- value: 0.5814882677801085 ± 0.0030396341196350686\n", - "- χ²: 1.157904323535443\n", + "- value: 0.5773601216615961 ± 0.00302334045912944\n", + "- χ²: 1.7757334563985634\n", "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" @@ -689,7 +689,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 22, "id": "f883b472", "metadata": {}, "outputs": [], @@ -699,7 +699,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 23, "id": "7fa0e4b4", "metadata": {}, "outputs": [ @@ -743,19 +743,19 @@ " 0.250000+0.000000j\n", " default\n", " True\n", - " 2021-10-21 13:36:26.085049+0200\n", + " 2021-10-21 14:21:13.496333+0200\n", " None\n", " \n", " \n", " 1\n", " amp\n", - " ()\n", - " x\n", - " 0.500000+0.000000j\n", + " (0,)\n", + " sx\n", + " 0.433005+0.000000j\n", " default\n", " True\n", - " 2021-10-21 13:36:26.085021+0200\n", - " None\n", + " 2021-10-21 14:39:49.487000+0200\n", + " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", " \n", " \n", " 2\n", @@ -765,41 +765,19 @@ " 0.500000+0.000000j\n", " default\n", " True\n", - " 2021-09-03 18:16:11.793776+0200\n", - " \n", + " 2021-10-21 14:21:13.496299+0200\n", + " None\n", " \n", " \n", " 3\n", " amp\n", " (0,)\n", - " sx\n", - " 0.397121+0.000000j\n", - " default\n", - " True\n", - " 2021-09-03 18:18:42.082000+0200\n", - " 7e6b27d5-c5a8-4477-a4a2-8c6a5fdb9be0\n", - " \n", - " \n", - " 4\n", - " amp\n", - " (0,)\n", - " sx\n", - " 0.429931+0.000000j\n", - " default\n", - " True\n", - " 2021-10-21 13:46:27.501000+0200\n", - " 5fb59cde-c1ec-4725-b1c4-fea7836f5463\n", - " \n", - " \n", - " 5\n", - " amp\n", - " (0,)\n", " x\n", - " 0.859863+0.000000j\n", + " 0.866011+0.000000j\n", " default\n", " True\n", - " 2021-10-21 13:46:27.501000+0200\n", - " 5fb59cde-c1ec-4725-b1c4-fea7836f5463\n", + " 2021-10-21 14:39:49.487000+0200\n", + " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", " \n", " \n", "\n", @@ -808,22 +786,18 @@ "text/plain": [ " parameter qubits schedule value group valid \\\n", "0 amp () sx 0.250000+0.000000j default True \n", - "1 amp () x 0.500000+0.000000j default True \n", + "1 amp (0,) sx 0.433005+0.000000j default True \n", "2 amp () x 0.500000+0.000000j default True \n", - "3 amp (0,) sx 0.397121+0.000000j default True \n", - "4 amp (0,) sx 0.429931+0.000000j default True \n", - "5 amp (0,) x 0.859863+0.000000j default True \n", + "3 amp (0,) x 0.866011+0.000000j default True \n", "\n", " date_time exp_id \n", - "0 2021-10-21 13:36:26.085049+0200 None \n", - "1 2021-10-21 13:36:26.085021+0200 None \n", - "2 2021-09-03 18:16:11.793776+0200 \n", - "3 2021-09-03 18:18:42.082000+0200 7e6b27d5-c5a8-4477-a4a2-8c6a5fdb9be0 \n", - "4 2021-10-21 13:46:27.501000+0200 5fb59cde-c1ec-4725-b1c4-fea7836f5463 \n", - "5 2021-10-21 13:46:27.501000+0200 5fb59cde-c1ec-4725-b1c4-fea7836f5463 " + "0 2021-10-21 14:21:13.496333+0200 None \n", + "1 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 \n", + "2 2021-10-21 14:21:13.496299+0200 None \n", + "3 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 " ] }, - "execution_count": 32, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -842,17 +816,17 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 24, "id": "bd9ff343", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=(0.42993129+0j), sigma=80, beta=0), DriveChannel(0)), name=\"sx\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=(0.43300531+0j), sigma=80, beta=0), DriveChannel(0)), name=\"sx\", transform=AlignLeft())" ] }, - "execution_count": 33, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -863,17 +837,17 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 25, "id": "95d75c23", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=(0.85986258+0j), sigma=80, beta=0), DriveChannel(0)), name=\"x\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=(0.86601063+0j), sigma=80, beta=0), DriveChannel(0)), name=\"x\", transform=AlignLeft())" ] }, - "execution_count": 34, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -884,17 +858,17 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 26, "id": "62b1318f", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=0.85986258j, sigma=80, beta=0), DriveChannel(0)), name=\"y\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=0.86601063j, sigma=80, beta=0), DriveChannel(0)), name=\"y\", transform=AlignLeft())" ] }, - "execution_count": 35, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -915,7 +889,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 27, "id": "317994db", "metadata": {}, "outputs": [ @@ -942,25 +916,10 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 28, "id": "24256b82", "metadata": {}, - "outputs": [ - { - "ename": "CalibrationError", - "evalue": "'No parameter for meas_lo_freq and schedule and qubits (0,). No default value exists.'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mCalibrationError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_22982/2476373101.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mcals\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBackendCalibrations\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbackend\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlibrary\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mcals\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_parameter_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Armonkparameter_values.csv\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Documents/IBM/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/calibrations.py\u001b[0m in \u001b[0;36mload_parameter_values\u001b[0;34m(self, file_name)\u001b[0m\n\u001b[1;32m 1065\u001b[0m )\n\u001b[1;32m 1066\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mParameterKey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"parameter\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_to_tuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"qubits\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrow\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"schedule\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1067\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_parameter_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparam_val\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1068\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1069\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mclassmethod\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/IBM/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/backend_calibrations.py\u001b[0m in \u001b[0;36madd_parameter_value\u001b[0;34m(self, value, param, qubits, schedule)\u001b[0m\n\u001b[1;32m 392\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mschedule\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 393\u001b[0m \u001b[0mschedule\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mschedule\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mschedule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mScheduleBlock\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mschedule\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 394\u001b[0;31m \u001b[0mparam_obj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcalibration_parameter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparam\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mqubits\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mschedule\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 395\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parameter_inst_map_update\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparam_obj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/IBM/qiskit/qiskit-experiments/qiskit_experiments/calibration_management/calibrations.py\u001b[0m in \u001b[0;36mcalibration_parameter\u001b[0;34m(self, parameter_name, qubits, schedule_name)\u001b[0m\n\u001b[1;32m 382\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parameter_map\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mParameterKey\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparameter_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mschedule_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 383\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 384\u001b[0;31m raise CalibrationError(\n\u001b[0m\u001b[1;32m 385\u001b[0m \u001b[0;34mf\"No parameter for {parameter_name} and schedule {schedule_name} \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 386\u001b[0m \u001b[0;34mf\"and qubits {qubits}. No default value exists.\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mCalibrationError\u001b[0m: 'No parameter for meas_lo_freq and schedule and qubits (0,). No default value exists.'" - ] - } - ], + "outputs": [], "source": [ "cals = BackendCalibrations(backend, library)\n", "cals.load_parameter_values(file_name=\"Armonkparameter_values.csv\")" @@ -968,7 +927,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 29, "id": "80ca665c", "metadata": {}, "outputs": [ @@ -993,106 +952,106 @@ " \n", " \n", " \n", + " parameter\n", + " qubits\n", + " schedule\n", " value\n", - " date_time\n", + " group\n", " valid\n", + " date_time\n", " exp_id\n", - " group\n", - " qubits\n", - " parameter\n", - " schedule\n", " \n", " \n", " \n", " \n", " 0\n", - " 0.500000+0.000000j\n", - " 2021-07-30 17:56:11.297378+0000\n", + " amp\n", + " ()\n", + " sx\n", + " 0.250000+0.000000j\n", + " default\n", " True\n", + " 2021-10-21 14:40:51.746391+0200\n", " None\n", - " default\n", - " ()\n", - " amp\n", - " x\n", " \n", " \n", " 1\n", - " 0.500000+0.000000j\n", - " 2021-07-30 17:53:14.422975+0000\n", + " amp\n", + " ()\n", + " sx\n", + " 0.250000+0.000000j\n", + " default\n", " True\n", + " 2021-10-21 14:21:13.496333+0200\n", " \n", - " default\n", - " ()\n", - " amp\n", - " x\n", " \n", " \n", " 2\n", - " 0.250000+0.000000j\n", - " 2021-07-30 17:56:11.297407+0000\n", - " True\n", - " None\n", - " default\n", - " ()\n", " amp\n", + " (0,)\n", " sx\n", + " 0.433005+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:39:49.487000+0200\n", + " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", " \n", " \n", " 3\n", - " 0.250000+0.000000j\n", - " 2021-07-30 17:53:14.422995+0000\n", - " True\n", - " \n", - " default\n", - " ()\n", " amp\n", - " sx\n", + " ()\n", + " x\n", + " 0.500000+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:40:51.746354+0200\n", + " None\n", " \n", " \n", " 4\n", - " 0.786215+0.000000j\n", - " 2021-07-31 02:56:07.570000+0900\n", - " True\n", - " fb23c9c4-1ef9-4c69-a623-0ff4dad4a956\n", - " default\n", - " (0,)\n", " amp\n", + " ()\n", " x\n", + " 0.500000+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:21:13.496299+0200\n", + " \n", " \n", " \n", " 5\n", - " 0.393107+0.000000j\n", - " 2021-07-31 02:56:07.570000+0900\n", - " True\n", - " fb23c9c4-1ef9-4c69-a623-0ff4dad4a956\n", - " default\n", - " (0,)\n", " amp\n", - " sx\n", + " (0,)\n", + " x\n", + " 0.866011+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:39:49.487000+0200\n", + " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", " \n", " \n", "\n", "" ], "text/plain": [ - " value date_time valid \\\n", - "0 0.500000+0.000000j 2021-07-30 17:56:11.297378+0000 True \n", - "1 0.500000+0.000000j 2021-07-30 17:53:14.422975+0000 True \n", - "2 0.250000+0.000000j 2021-07-30 17:56:11.297407+0000 True \n", - "3 0.250000+0.000000j 2021-07-30 17:53:14.422995+0000 True \n", - "4 0.786215+0.000000j 2021-07-31 02:56:07.570000+0900 True \n", - "5 0.393107+0.000000j 2021-07-31 02:56:07.570000+0900 True \n", + " parameter qubits schedule value group valid \\\n", + "0 amp () sx 0.250000+0.000000j default True \n", + "1 amp () sx 0.250000+0.000000j default True \n", + "2 amp (0,) sx 0.433005+0.000000j default True \n", + "3 amp () x 0.500000+0.000000j default True \n", + "4 amp () x 0.500000+0.000000j default True \n", + "5 amp (0,) x 0.866011+0.000000j default True \n", "\n", - " exp_id group qubits parameter schedule \n", - "0 None default () amp x \n", - "1 default () amp x \n", - "2 None default () amp sx \n", - "3 default () amp sx \n", - "4 fb23c9c4-1ef9-4c69-a623-0ff4dad4a956 default (0,) amp x \n", - "5 fb23c9c4-1ef9-4c69-a623-0ff4dad4a956 default (0,) amp sx " + " date_time exp_id \n", + "0 2021-10-21 14:40:51.746391+0200 None \n", + "1 2021-10-21 14:21:13.496333+0200 \n", + "2 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 \n", + "3 2021-10-21 14:40:51.746354+0200 None \n", + "4 2021-10-21 14:21:13.496299+0200 \n", + "5 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 " ] }, - "execution_count": 31, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1388,7 +1347,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 30, "id": "20ab91f2", "metadata": {}, "outputs": [], @@ -1398,7 +1357,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 31, "id": "bfb3124b", "metadata": {}, "outputs": [], @@ -1408,7 +1367,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 32, "id": "c6127e65", "metadata": {}, "outputs": [ @@ -1419,7 +1378,7 @@ "
" ] }, - "execution_count": 24, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -1430,39 +1389,28 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 33, "id": "24067164", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ExperimentData(FineXAmplitude, 65378703-3c55-4193-aa42-81e69425aa42, backend=ibmq_armonk, job_ids=['61043dac754b9d825454607d'])" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "data_fine = amp_x_cal.run(backend).block_for_results()" ] }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 34, "id": "076bed0c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 44, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -1473,7 +1421,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 35, "id": "cf2cc09a", "metadata": {}, "outputs": [ @@ -1483,8 +1431,8 @@ "text": [ "DbAnalysisResultV1\n", "- name: d_theta\n", - "- value: -0.0662944270879526 ± 0.00225309047635176\n", - "- χ²: 0.9234748761823247\n", + "- value: -0.10585059452665099 ± 0.0036016923711092905\n", + "- χ²: 1.2761864922591215\n", "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" @@ -1505,7 +1453,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 36, "id": "81adf659", "metadata": {}, "outputs": [ @@ -1513,8 +1461,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "The ideal angle is 3.14 rad. We measured a deviation of -0.066 rad.\n", - "Thus, scale the 0.7862+0.0000j pulse amplitude by 1.022 to obtain 0.80316+0.00000j.\n" + "The ideal angle is 3.14 rad. We measured a deviation of -0.106 rad.\n", + "Thus, scale the 0.8962+0.0000j pulse amplitude by 1.035 to obtain 0.92746+0.00000j.\n" ] } ], @@ -1528,18 +1476,16 @@ ] }, { - "cell_type": "code", - "execution_count": 47, - "id": "f15bbb4d", + "cell_type": "markdown", + "id": "97c69c65", "metadata": {}, - "outputs": [], "source": [ - "Amplitude.update(cals, data_fine, angles_schedules=[(target_angle, \"amp\", \"x\")])" + "Observe, once again, that the calibrations have automatically been updated." ] }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 37, "id": "81e7f3de", "metadata": {}, "outputs": [ @@ -1564,119 +1510,119 @@ " \n", " \n", " \n", + " parameter\n", + " qubits\n", + " schedule\n", " value\n", - " date_time\n", + " group\n", " valid\n", + " date_time\n", " exp_id\n", - " group\n", - " qubits\n", - " parameter\n", - " schedule\n", " \n", " \n", " \n", " \n", " 0\n", - " 0.500000+0.000000j\n", - " 2021-07-30 17:56:11.297378+0000\n", + " amp\n", + " ()\n", + " sx\n", + " 0.250000+0.000000j\n", + " default\n", " True\n", + " 2021-10-21 14:40:51.746391+0200\n", " None\n", - " default\n", - " ()\n", - " amp\n", - " x\n", " \n", " \n", " 1\n", - " 0.500000+0.000000j\n", - " 2021-07-30 17:53:14.422975+0000\n", + " amp\n", + " ()\n", + " sx\n", + " 0.250000+0.000000j\n", + " default\n", " True\n", + " 2021-10-21 14:21:13.496333+0200\n", " \n", - " default\n", - " ()\n", - " amp\n", - " x\n", " \n", " \n", " 2\n", - " 0.250000+0.000000j\n", - " 2021-07-30 17:56:11.297407+0000\n", - " True\n", - " None\n", - " default\n", - " ()\n", " amp\n", + " (0,)\n", " sx\n", + " 0.433005+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:39:49.487000+0200\n", + " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", " \n", " \n", " 3\n", - " 0.250000+0.000000j\n", - " 2021-07-30 17:53:14.422995+0000\n", - " True\n", - " \n", - " default\n", - " ()\n", " amp\n", - " sx\n", + " ()\n", + " x\n", + " 0.500000+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:40:51.746354+0200\n", + " None\n", " \n", " \n", " 4\n", - " 0.786215+0.000000j\n", - " 2021-07-31 02:56:07.570000+0900\n", - " True\n", - " fb23c9c4-1ef9-4c69-a623-0ff4dad4a956\n", - " default\n", - " (0,)\n", " amp\n", + " ()\n", " x\n", + " 0.500000+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:21:13.496299+0200\n", + " \n", " \n", " \n", " 5\n", - " 0.803163+0.000000j\n", - " 2021-07-31 02:58:42.977000+0900\n", - " True\n", - " 65378703-3c55-4193-aa42-81e69425aa42\n", - " default\n", - " (0,)\n", " amp\n", + " (0,)\n", " x\n", + " 0.866011+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:39:49.487000+0200\n", + " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", " \n", " \n", " 6\n", - " 0.393107+0.000000j\n", - " 2021-07-31 02:56:07.570000+0900\n", - " True\n", - " fb23c9c4-1ef9-4c69-a623-0ff4dad4a956\n", - " default\n", - " (0,)\n", " amp\n", - " sx\n", + " (0,)\n", + " x\n", + " 0.896207+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:42:13.806000+0200\n", + " 1507e843-ca7f-4670-a2a8-ad3bbc51fe0c\n", " \n", " \n", "\n", "" ], "text/plain": [ - " value date_time valid \\\n", - "0 0.500000+0.000000j 2021-07-30 17:56:11.297378+0000 True \n", - "1 0.500000+0.000000j 2021-07-30 17:53:14.422975+0000 True \n", - "2 0.250000+0.000000j 2021-07-30 17:56:11.297407+0000 True \n", - "3 0.250000+0.000000j 2021-07-30 17:53:14.422995+0000 True \n", - "4 0.786215+0.000000j 2021-07-31 02:56:07.570000+0900 True \n", - "5 0.803163+0.000000j 2021-07-31 02:58:42.977000+0900 True \n", - "6 0.393107+0.000000j 2021-07-31 02:56:07.570000+0900 True \n", + " parameter qubits schedule value group valid \\\n", + "0 amp () sx 0.250000+0.000000j default True \n", + "1 amp () sx 0.250000+0.000000j default True \n", + "2 amp (0,) sx 0.433005+0.000000j default True \n", + "3 amp () x 0.500000+0.000000j default True \n", + "4 amp () x 0.500000+0.000000j default True \n", + "5 amp (0,) x 0.866011+0.000000j default True \n", + "6 amp (0,) x 0.896207+0.000000j default True \n", "\n", - " exp_id group qubits parameter schedule \n", - "0 None default () amp x \n", - "1 default () amp x \n", - "2 None default () amp sx \n", - "3 default () amp sx \n", - "4 fb23c9c4-1ef9-4c69-a623-0ff4dad4a956 default (0,) amp x \n", - "5 65378703-3c55-4193-aa42-81e69425aa42 default (0,) amp x \n", - "6 fb23c9c4-1ef9-4c69-a623-0ff4dad4a956 default (0,) amp sx " + " date_time exp_id \n", + "0 2021-10-21 14:40:51.746391+0200 None \n", + "1 2021-10-21 14:21:13.496333+0200 \n", + "2 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 \n", + "3 2021-10-21 14:40:51.746354+0200 None \n", + "4 2021-10-21 14:21:13.496299+0200 \n", + "5 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 \n", + "6 2021-10-21 14:42:13.806000+0200 1507e843-ca7f-4670-a2a8-ad3bbc51fe0c " ] }, - "execution_count": 48, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" } @@ -1695,50 +1641,28 @@ }, { "cell_type": "code", - "execution_count": 49, - "id": "5f1f9c3c", - "metadata": {}, - "outputs": [], - "source": [ - "amp_x_cal.set_experiment_options(schedule=cals.get_schedule(\"x\", qubit))" - ] - }, - { - "cell_type": "code", - "execution_count": 50, + "execution_count": 38, "id": "84146c1a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ExperimentData(FineXAmplitude, cd788032-5b57-43b9-939a-38e158b2290b, backend=ibmq_armonk, job_ids=['61043dd7c2c8569398bbe00d'])" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "data_fine2 = amp_x_cal.run(backend)\n", - "data_fine2.block_for_results()" + "data_fine2 = amp_x_cal.run(backend).block_for_results()" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 39, "id": "5218f8e0", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 51, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -1757,7 +1681,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 40, "id": "25ddccd3", "metadata": {}, "outputs": [ @@ -1767,8 +1691,8 @@ "text": [ "DbAnalysisResultV1\n", "- name: d_theta\n", - "- value: -0.01342494104730634 ± 0.00123755860439784\n", - "- χ²: 1.0175384109483505\n", + "- value: -0.023041381974401358 ± 0.001382763290893336\n", + "- χ²: 1.8251091489996691\n", "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" @@ -1791,39 +1715,38 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 41, "id": "50423105", "metadata": {}, "outputs": [], "source": [ - "from qiskit_experiments.library.calibration.fine_amplitude import FineSXAmplitude" + "from qiskit_experiments.library.calibration.fine_amplitude import FineSXAmplitudeCal" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 43, "id": "a075eacb", "metadata": {}, "outputs": [], "source": [ - "amp_sx_cal = FineSXAmplitude(qubit)\n", - "amp_sx_cal.set_experiment_options(schedule=cals.get_schedule(\"sx\", qubit))" + "amp_sx_cal = FineSXAmplitudeCal(qubit, cals, schedule_name=\"sx\")" ] }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 44, "id": "3d38a13f", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, - "execution_count": 56, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } @@ -1834,40 +1757,28 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 45, "id": "6c00c3f5", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ExperimentData(FineSXAmplitude, 974aec93-a139-40f5-8417-2d781c1defb4, backend=ibmq_armonk, job_ids=['61043e0c1e71b01061bfc3d5'])" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "data_fine_sx = amp_sx_cal.run(backend)\n", - "data_fine_sx.block_for_results()" + "data_fine_sx = amp_sx_cal.run(backend).block_for_results()" ] }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 46, "id": "0117cb2d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "execution_count": 58, + "execution_count": 46, "metadata": {}, "output_type": "execute_result" } @@ -1878,7 +1789,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 47, "id": "5d5a1131", "metadata": {}, "outputs": [ @@ -1888,8 +1799,8 @@ "text": [ "DbAnalysisResultV1\n", "- name: d_theta\n", - "- value: 0.10255665062411463 ± 0.0009757998694015175\n", - "- χ²: 1.0600906241777\n", + "- value: 0.04145980422899995 ± 0.0015231144619942427\n", + "- χ²: 1.0258195129532202\n", "- quality: good\n", "- device_components: ['Q0']\n", "- verified: False\n" @@ -1901,18 +1812,16 @@ ] }, { - "cell_type": "code", - "execution_count": 60, - "id": "b1dc7486", + "cell_type": "markdown", + "id": "72571816", "metadata": {}, - "outputs": [], "source": [ - "Amplitude.update(cals, data_fine_sx, angles_schedules=[(np.pi/2, \"amp\", \"sx\")])" + "The parameter value is reflected in the calibrations." ] }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 48, "id": "ae984c47", "metadata": {}, "outputs": [ @@ -1937,132 +1846,145 @@ " \n", " \n", " \n", + " parameter\n", + " qubits\n", + " schedule\n", " value\n", - " date_time\n", + " group\n", " valid\n", + " date_time\n", " exp_id\n", - " group\n", - " qubits\n", - " parameter\n", - " schedule\n", " \n", " \n", " \n", " \n", " 0\n", - " 0.500000+0.000000j\n", - " 2021-07-30 17:56:11.297378+0000\n", + " amp\n", + " ()\n", + " sx\n", + " 0.250000+0.000000j\n", + " default\n", " True\n", + " 2021-10-21 14:40:51.746391+0200\n", " None\n", - " default\n", - " ()\n", - " amp\n", - " x\n", " \n", " \n", " 1\n", - " 0.500000+0.000000j\n", - " 2021-07-30 17:53:14.422975+0000\n", + " amp\n", + " ()\n", + " sx\n", + " 0.250000+0.000000j\n", + " default\n", " True\n", + " 2021-10-21 14:21:13.496333+0200\n", " \n", - " default\n", - " ()\n", - " amp\n", - " x\n", " \n", " \n", " 2\n", - " 0.250000+0.000000j\n", - " 2021-07-30 17:56:11.297407+0000\n", - " True\n", - " None\n", - " default\n", - " ()\n", " amp\n", + " (0,)\n", " sx\n", + " 0.433005+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:39:49.487000+0200\n", + " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", " \n", " \n", " 3\n", - " 0.250000+0.000000j\n", - " 2021-07-30 17:53:14.422995+0000\n", - " True\n", - " \n", - " default\n", - " ()\n", " amp\n", + " (0,)\n", " sx\n", + " 0.421870+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:46:58.782000+0200\n", + " ce7fdf7f-1243-44f8-92b3-2861f75b955e\n", " \n", " \n", " 4\n", - " 0.786215+0.000000j\n", - " 2021-07-31 02:56:07.570000+0900\n", - " True\n", - " fb23c9c4-1ef9-4c69-a623-0ff4dad4a956\n", - " default\n", - " (0,)\n", " amp\n", + " ()\n", " x\n", + " 0.500000+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:40:51.746354+0200\n", + " None\n", " \n", " \n", " 5\n", - " 0.803163+0.000000j\n", - " 2021-07-31 02:58:42.977000+0900\n", - " True\n", - " 65378703-3c55-4193-aa42-81e69425aa42\n", - " default\n", - " (0,)\n", " amp\n", + " ()\n", " x\n", + " 0.500000+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:21:13.496299+0200\n", + " \n", " \n", " \n", " 6\n", - " 0.393107+0.000000j\n", - " 2021-07-31 02:56:07.570000+0900\n", - " True\n", - " fb23c9c4-1ef9-4c69-a623-0ff4dad4a956\n", - " default\n", - " (0,)\n", " amp\n", - " sx\n", + " (0,)\n", + " x\n", + " 0.866011+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:39:49.487000+0200\n", + " 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397\n", " \n", " \n", " 7\n", - " 0.369015+0.000000j\n", - " 2021-07-31 03:00:06.651000+0900\n", - " True\n", - " 974aec93-a139-40f5-8417-2d781c1defb4\n", - " default\n", + " amp\n", " (0,)\n", + " x\n", + " 0.896207+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:42:13.806000+0200\n", + " 1507e843-ca7f-4670-a2a8-ad3bbc51fe0c\n", + " \n", + " \n", + " 8\n", " amp\n", - " sx\n", + " (0,)\n", + " x\n", + " 0.902828+0.000000j\n", + " default\n", + " True\n", + " 2021-10-21 14:44:44.903000+0200\n", + " 31ae56ba-bad3-4eed-9a80-7e54282318f7\n", " \n", " \n", "\n", "" ], "text/plain": [ - " value date_time valid \\\n", - "0 0.500000+0.000000j 2021-07-30 17:56:11.297378+0000 True \n", - "1 0.500000+0.000000j 2021-07-30 17:53:14.422975+0000 True \n", - "2 0.250000+0.000000j 2021-07-30 17:56:11.297407+0000 True \n", - "3 0.250000+0.000000j 2021-07-30 17:53:14.422995+0000 True \n", - "4 0.786215+0.000000j 2021-07-31 02:56:07.570000+0900 True \n", - "5 0.803163+0.000000j 2021-07-31 02:58:42.977000+0900 True \n", - "6 0.393107+0.000000j 2021-07-31 02:56:07.570000+0900 True \n", - "7 0.369015+0.000000j 2021-07-31 03:00:06.651000+0900 True \n", + " parameter qubits schedule value group valid \\\n", + "0 amp () sx 0.250000+0.000000j default True \n", + "1 amp () sx 0.250000+0.000000j default True \n", + "2 amp (0,) sx 0.433005+0.000000j default True \n", + "3 amp (0,) sx 0.421870+0.000000j default True \n", + "4 amp () x 0.500000+0.000000j default True \n", + "5 amp () x 0.500000+0.000000j default True \n", + "6 amp (0,) x 0.866011+0.000000j default True \n", + "7 amp (0,) x 0.896207+0.000000j default True \n", + "8 amp (0,) x 0.902828+0.000000j default True \n", "\n", - " exp_id group qubits parameter schedule \n", - "0 None default () amp x \n", - "1 default () amp x \n", - "2 None default () amp sx \n", - "3 default () amp sx \n", - "4 fb23c9c4-1ef9-4c69-a623-0ff4dad4a956 default (0,) amp x \n", - "5 65378703-3c55-4193-aa42-81e69425aa42 default (0,) amp x \n", - "6 fb23c9c4-1ef9-4c69-a623-0ff4dad4a956 default (0,) amp sx \n", - "7 974aec93-a139-40f5-8417-2d781c1defb4 default (0,) amp sx " + " date_time exp_id \n", + "0 2021-10-21 14:40:51.746391+0200 None \n", + "1 2021-10-21 14:21:13.496333+0200 \n", + "2 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 \n", + "3 2021-10-21 14:46:58.782000+0200 ce7fdf7f-1243-44f8-92b3-2861f75b955e \n", + "4 2021-10-21 14:40:51.746354+0200 None \n", + "5 2021-10-21 14:21:13.496299+0200 \n", + "6 2021-10-21 14:39:49.487000+0200 1b5c7f5c-2a93-4beb-a3cd-037e3f18c397 \n", + "7 2021-10-21 14:42:13.806000+0200 1507e843-ca7f-4670-a2a8-ad3bbc51fe0c \n", + "8 2021-10-21 14:44:44.903000+0200 31ae56ba-bad3-4eed-9a80-7e54282318f7 " ] }, - "execution_count": 61, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } @@ -2073,17 +1995,17 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 49, "id": "f7cb5878", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=(0.369014607022268+0j), sigma=80, beta=0), DriveChannel(0)), name=\"sx\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=(0.421870407153443+0j), sigma=80, beta=0), DriveChannel(0)), name=\"sx\", transform=AlignLeft())" ] }, - "execution_count": 62, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -2094,17 +2016,17 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 50, "id": "f45f6482", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=(0.80316333037296+0j), sigma=80, beta=-0.842466355165788), DriveChannel(0)), name=\"x\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=(0.902828399794558+0j), sigma=80, beta=0), DriveChannel(0)), name=\"x\", transform=AlignLeft())" ] }, - "execution_count": 63, + "execution_count": 50, "metadata": {}, "output_type": "execute_result" } @@ -2115,17 +2037,17 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 51, "id": "68f6e469", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "ScheduleBlock(Play(Drag(duration=320, amp=0.80316333037296j, sigma=80, beta=-0.842466355165788), DriveChannel(0)), name=\"y\", transform=AlignLeft())" + "ScheduleBlock(Play(Drag(duration=320, amp=0.902828399794558j, sigma=80, beta=0), DriveChannel(0)), name=\"y\", transform=AlignLeft())" ] }, - "execution_count": 64, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" } @@ -2136,7 +2058,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 52, "id": "8c8369d4", "metadata": {}, "outputs": [ diff --git a/qiskit_experiments/calibration_management/calibrations.py b/qiskit_experiments/calibration_management/calibrations.py index 3787a200ac..37ca3971ea 100644 --- a/qiskit_experiments/calibration_management/calibrations.py +++ b/qiskit_experiments/calibration_management/calibrations.py @@ -1063,7 +1063,13 @@ def load_parameter_values(self, file_name: str = "parameter_values.csv"): param_val = ParameterValue( row["value"], row["date_time"], row["valid"], row["exp_id"], row["group"] ) - key = ParameterKey(row["parameter"], self._to_tuple(row["qubits"]), row["schedule"]) + + if row["schedule"] == "": + schedule_name = None + else: + schedule_name = row["schedule"] + + key = ParameterKey(row["parameter"], self._to_tuple(row["qubits"]), schedule_name) self.add_parameter_value(param_val, *key) @classmethod From 70f3b211dfed733ec3872f1684007e1e88f3e9f0 Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:05:02 +0200 Subject: [PATCH 08/19] Update qiskit_experiments/library/characterization/fine_amplitude.py Co-authored-by: Will Shanks --- qiskit_experiments/library/characterization/fine_amplitude.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index 1a68f953b4..c29d9e561b 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -49,7 +49,7 @@ class FineAmplitude(BaseExperiment): The user can optionally add a square-root of X pulse before the Cal gates are repeated. This square-root of X pulse allows the analysis to differentiate between over rotations and under rotations in the case of pi-pulses. Importantly, the resulting data is analyzed - by a fit to a cosine function in which we try and determine the over/under rotation given + by a fit to a cosine function in which we try to determine the over/under rotation given an intended rotation angle per gate which must also be specified by the user. Error amplifying experiments are most sensitive to angle errors when we measure points along From 5bebeab630f880a3db107bb7dd6141264c91dba3 Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:06:13 +0200 Subject: [PATCH 09/19] Update qiskit_experiments/library/characterization/fine_amplitude.py Co-authored-by: Will Shanks --- .../library/characterization/fine_amplitude.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index c29d9e561b..e95e2f61a8 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -54,11 +54,14 @@ class FineAmplitude(BaseExperiment): Error amplifying experiments are most sensitive to angle errors when we measure points along the equator of the Block sphere. This is why users should insert a square-root of X pulse - before running calibrations for :math:`\pm\pi` rotations. Furthermore, when running - calibrations for :math:`\pm\pi/2` rotations users are advised to use an odd number of - repetitions, e.g. [1, 2, 3, 5, 7, ...] to ensure that the ideal points are on the equator - of the Bloch sphere. Note the presence of two repetitions which allows us to prepare the - excited state. Therefore, add_xp_circuit = True is not needed in this case. + before running calibrations for :math:`\pm\pi` rotations. When all data points are close to + the equator, it is difficult for a fitter to infer the overall scale of the error. When calibrating + a :math:`pi` rotation, one can use ``add_xp_circuit = True`` to insert one circuit that puts + the qubit in the excited state to set the scale for the other circuits. Furthermore, when + running calibrations for :math:`\pm\pi/2` rotations users are advised to use an odd + number of repetitions, e.g. [1, 2, 3, 5, 7, ...] to ensure that the ideal points are on the + equator of the Bloch sphere. Note the presence of two repetitions which allows us to + prepare the excited state. Therefore, ``add_xp_circuit = True`` is not needed in this case. Users can call :meth:`set_schedule` to conveniently set the schedule and the corresponding experiment and analysis options. From 44450f6d452bff6bbfeffc62c8672773c1d8142e Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:06:25 +0200 Subject: [PATCH 10/19] Update qiskit_experiments/library/characterization/fine_amplitude.py Co-authored-by: Will Shanks --- qiskit_experiments/library/characterization/fine_amplitude.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index e95e2f61a8..feba973c6e 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -53,7 +53,7 @@ class FineAmplitude(BaseExperiment): an intended rotation angle per gate which must also be specified by the user. Error amplifying experiments are most sensitive to angle errors when we measure points along - the equator of the Block sphere. This is why users should insert a square-root of X pulse + the equator of the Bloch sphere. This is why users should insert a square-root of X pulse before running calibrations for :math:`\pm\pi` rotations. When all data points are close to the equator, it is difficult for a fitter to infer the overall scale of the error. When calibrating a :math:`pi` rotation, one can use ``add_xp_circuit = True`` to insert one circuit that puts From 4e54e95e465e4d74d10cb913e6b024a1be0d8236 Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:07:06 +0200 Subject: [PATCH 11/19] Update qiskit_experiments/library/characterization/fine_amplitude.py Co-authored-by: Will Shanks --- qiskit_experiments/library/characterization/fine_amplitude.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index feba973c6e..231044aaa7 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -85,7 +85,8 @@ class FineAmplitude(BaseExperiment): Note that the ``schedule`` and ``angle_per_gate`` could have been set by independently calling :meth:`set_experiment_options` for the ``schedule`` and :meth:`set_analysis_options` for - the ``angle_per_gate``. + the ``angle_per_gate``. Note that there are subclasses of :class:`FineAmplitude` such as + :class:`FineSXAmplitude` that set the appropriate options by default for specific schedules. # section: reference From 4f1b2df82f0cf3c8a35479f4f4581e9533eb0d7c Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:07:35 +0200 Subject: [PATCH 12/19] Update qiskit_experiments/library/characterization/fine_amplitude.py Co-authored-by: Will Shanks --- qiskit_experiments/library/characterization/fine_amplitude.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index 231044aaa7..c1229c51a4 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -69,7 +69,7 @@ class FineAmplitude(BaseExperiment): # section: example - The steps to run a fine amplitude calibration experiment are + The steps to run a fine amplitude experiment are .. code-block:: python From 7c829e188ce8d464a2964505c5557421fc4ca587 Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:08:20 +0200 Subject: [PATCH 13/19] Update qiskit_experiments/library/characterization/fine_amplitude.py Co-authored-by: Will Shanks --- qiskit_experiments/library/characterization/fine_amplitude.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index c1229c51a4..4cf4e8ba72 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -157,8 +157,7 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: backend: A backend object. Returns: - A list of circuits with a variable number of gates. Each gate has the same - pulse schedule. + A list of circuits with a variable number of gates. Raises: CalibrationError: If no schedule was provided. From 15000f6f4c28b0745ed6763d338b5f4d12d03f54 Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:10:21 +0200 Subject: [PATCH 14/19] Update qiskit_experiments/library/characterization/fine_amplitude.py Co-authored-by: Will Shanks --- qiskit_experiments/library/characterization/fine_amplitude.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index 4cf4e8ba72..e9465106f0 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -160,9 +160,6 @@ def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: A list of circuits with a variable number of gates. Raises: - CalibrationError: If no schedule was provided. - CalibrationError: If the channel index does not correspond to the physical qubit index. - CalibrationError: If the schedule contains unassigned parameters. CalibrationError: If the analysis options do not contain the angle_per_gate. """ # Prepare the circuits. From b650b7e453eab465e65c77ad94045d11003f102c Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:10:30 +0200 Subject: [PATCH 15/19] Update qiskit_experiments/library/calibration/fine_amplitude.py Co-authored-by: Will Shanks --- qiskit_experiments/library/calibration/fine_amplitude.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_experiments/library/calibration/fine_amplitude.py b/qiskit_experiments/library/calibration/fine_amplitude.py index 211c4a0bd3..4245dc53fa 100644 --- a/qiskit_experiments/library/calibration/fine_amplitude.py +++ b/qiskit_experiments/library/calibration/fine_amplitude.py @@ -27,7 +27,7 @@ class FineAmplitudeCal(BaseCalibrationExperiment, FineAmplitude): - """A calibration version of the fine amplitude experiment.""" + """A calibration version of the :class:`FineAmplitude` experiment.""" def __init__( self, From 77dbe7f75382093498243658b542e519a4f8b61f Mon Sep 17 00:00:00 2001 From: "Daniel J. Egger" <38065505+eggerdj@users.noreply.github.com> Date: Thu, 21 Oct 2021 19:10:38 +0200 Subject: [PATCH 16/19] Update qiskit_experiments/library/characterization/fine_amplitude.py Co-authored-by: Will Shanks --- qiskit_experiments/library/characterization/fine_amplitude.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index e9465106f0..872e8b5e0b 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -276,8 +276,7 @@ def _default_experiment_options(cls) -> Options: Experiment Options: gate (Gate): FineSXAmplitude calibrates an SXGate. add_sx (bool): This option is False by default when calibrating gates with a target - angle per gate of :math:`\pi/2` as this increases the sensitivity of the - experiment. + angle per gate of :math:`\pi/2` as it is not necessary in this case. add_xp_circuit (bool): This option is False by default when calibrating gates with a target angle per gate of :math:`\pi/2`. repetitions (List[int]): By default the repetitions take on odd numbers for From 77d94cb43c4c794c38e6966c21aa616cf7d55fe0 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 21 Oct 2021 19:23:50 +0200 Subject: [PATCH 17/19] * Documentation. --- .../library/calibration/fine_amplitude.py | 9 +++- .../characterization/fine_amplitude.py | 46 ++++++++----------- 2 files changed, 26 insertions(+), 29 deletions(-) diff --git a/qiskit_experiments/library/calibration/fine_amplitude.py b/qiskit_experiments/library/calibration/fine_amplitude.py index 4245dc53fa..27c020bc63 100644 --- a/qiskit_experiments/library/calibration/fine_amplitude.py +++ b/qiskit_experiments/library/calibration/fine_amplitude.py @@ -27,7 +27,14 @@ class FineAmplitudeCal(BaseCalibrationExperiment, FineAmplitude): - """A calibration version of the :class:`FineAmplitude` experiment.""" + r"""A calibration version of the :class:`FineAmplitude` experiment. + + # section: overview + + :class:`FineAmplitudeCal` is a subclass of :class:`FineAmplitude`. In the calibration + experiment the circuits that are run have a custom gate with the pulse schedule attached + to it through the calibrations. + """ def __init__( self, diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index 872e8b5e0b..3f1dcb877d 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -34,23 +34,22 @@ class FineAmplitude(BaseExperiment): The :class:`FineAmplitude` calibration experiment repeats N times a gate with a pulse to amplify the under-/over-rotations in the gate to determine the optimal amplitude. - The circuits that are run have a custom gate with the pulse schedule attached to it - through the calibrations. The circuits are therefore of the form: + The circuits are therefore of the form: .. parsed-literal:: - ┌─────┐ ┌─────┐ ░ ┌─┐ - q_0: ┤ Cal ├─ ... ─┤ Cal ├─░─┤M├ - └─────┘ └─────┘ ░ └╥┘ - measure: 1/════════ ... ════════════╩═ - 0 + ┌──────┐ ┌──────┐ ░ ┌─┐ + q_0: ┤ Gate ├─ ... ─┤ Gate ├─░─┤M├ + └──────┘ └──────┘ ░ └╥┘ + measure: 1/═════════ ... ═════════════╩═ + 0 - Here, Cal is the name of the gate which will be taken from the name of the schedule. - The user can optionally add a square-root of X pulse before the Cal gates are repeated. - This square-root of X pulse allows the analysis to differentiate between over rotations - and under rotations in the case of pi-pulses. Importantly, the resulting data is analyzed - by a fit to a cosine function in which we try to determine the over/under rotation given - an intended rotation angle per gate which must also be specified by the user. + Here, Gate is the name of the gate which will be repeated. The user can optionally add a + square-root of X pulse before the gates are repeated. This square-root of X pulse allows + the analysis to differentiate between over rotations and under rotations in the case of + pi-pulses. Importantly, the resulting data is analyzed by a fit to a cosine function in + which we try to determine the over/under rotation given an intended rotation angle per + gate which must also be specified by the user. Error amplifying experiments are most sensitive to angle errors when we measure points along the equator of the Bloch sphere. This is why users should insert a square-root of X pulse @@ -63,30 +62,23 @@ class FineAmplitude(BaseExperiment): equator of the Bloch sphere. Note the presence of two repetitions which allows us to prepare the excited state. Therefore, ``add_xp_circuit = True`` is not needed in this case. - Users can call :meth:`set_schedule` to conveniently set the schedule and the corresponding - experiment and analysis options. - # section: example - The steps to run a fine amplitude experiment are .. code-block:: python qubit = 3 - amp_cal = FineAmplitude(qubit) - amp_cal.set_schedule( - schedule=x90p, + amp_cal = FineAmplitude(qubit, SXGate()) + amp_cal.set_experiment_options( angle_per_gate=np.pi/2, add_xp_circuit=False, add_sx=False ) amp_cal.run(backend) - Note that the ``schedule`` and ``angle_per_gate`` could have been set by independently calling - :meth:`set_experiment_options` for the ``schedule`` and :meth:`set_analysis_options` for - the ``angle_per_gate``. Note that there are subclasses of :class:`FineAmplitude` such as - :class:`FineSXAmplitude` that set the appropriate options by default for specific schedules. + Note that there are subclasses of :class:`FineAmplitude` such as :class:`FineSXAmplitude` + that set the appropriate options by default. # section: reference @@ -106,8 +98,7 @@ def _default_experiment_options(cls) -> Options: Experiment Options: repetitions (List[int]): A list of the number of times that the gate is repeated. - schedule (ScheduleBlock): The schedule attached to the gate that will be repeated. - gate_type (Type): This is a gate class such as XGate, so that one can obtain a gate + gate_type (Gate): This is a gate class such as XGate, so that one can obtain a gate by doing :code:`options.gate_class()`. normalization (bool): If set to True the DataProcessor will normalized the measured signal to the interval [0, 1]. Defaults to True. @@ -116,7 +107,6 @@ def _default_experiment_options(cls) -> Options: default value is False. add_xp_circuit (bool): If set to True then a circuit with only an X gate will also be run. This allows the analysis class to determine the correct sign for the amplitude. - sx_schedule (ScheduleBlock): The schedule to attache to the SX gate. """ options = super()._default_experiment_options() options.repetitions = list(range(15)) @@ -140,7 +130,7 @@ def __init__(self, qubit: int, gate: Gate): def _pre_circuit(self) -> QuantumCircuit: """Return a preparation circuit. - This method can be overridden by subclasses e.g. to calibrate schedules on + This method can be overridden by subclasses e.g. to calibrate gates on transitions other than the 0 <-> 1 transition. """ circuit = QuantumCircuit(1) From e473d3f2743176500ec60344e4d09ae3d269987f Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Thu, 21 Oct 2021 19:27:30 +0200 Subject: [PATCH 18/19] * Documentation. --- qiskit_experiments/library/characterization/fine_amplitude.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index 3f1dcb877d..40392dc2c0 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -222,7 +222,7 @@ def _default_experiment_options(cls) -> Options: r"""Default values for the fine amplitude experiment. Experiment Options: - gate (Gate): FineXAmplitude calibrates an XGate. + gate (Gate): Gate to characterize. Defaults to an XGate. add_sx (bool): This option is True by default when calibrating gates with a target angle per gate of :math:`\pi` as this increases the sensitivity of the experiment. From 735d81ea61e8b6c225ac8308718fca2ebb4d8c52 Mon Sep 17 00:00:00 2001 From: Daniel Egger Date: Fri, 22 Oct 2021 13:18:50 +0200 Subject: [PATCH 19/19] * Added metadata hook in base class. * Added metadata in fine amp cal circuits. --- .../base_calibration_experiment.py | 21 +++++- .../library/calibration/fine_amplitude.py | 72 +++++++++++++------ .../characterization/fine_amplitude.py | 15 ++-- 3 files changed, 76 insertions(+), 32 deletions(-) diff --git a/qiskit_experiments/calibration_management/base_calibration_experiment.py b/qiskit_experiments/calibration_management/base_calibration_experiment.py index 8b3856dcc9..f61506d7a3 100644 --- a/qiskit_experiments/calibration_management/base_calibration_experiment.py +++ b/qiskit_experiments/calibration_management/base_calibration_experiment.py @@ -13,11 +13,11 @@ """Base class for calibration-type experiments.""" from abc import ABC -from typing import Dict, Optional, Tuple, Type +from typing import Dict, List, Optional, Tuple, Type import warnings from qiskit.providers.backend import Backend -from qiskit.circuit import Parameter +from qiskit.circuit import Parameter, QuantumCircuit from qiskit.pulse import ScheduleBlock from qiskit_experiments.calibration_management.calibrations import Calibrations @@ -339,6 +339,23 @@ def get_schedule( return schedules + def circuits(self, backend: Optional[Backend] = None) -> List[QuantumCircuit]: + """A wrapper to introduce an optional hook to add circuit metadata.""" + circuits = super().circuits(backend) + + self._add_cal_metadata(circuits) + + return circuits + + def _add_cal_metadata(self, circuits: List[QuantumCircuit]): + """A hook to add calibration metadata to the circuits. + + Many calibration experiments will not define the circuits method but rely on those defined + by the experiment in the characterization module. This hook allows calibration experiments + to add their own meta data to the circuits if needed. + """ + pass + def run( self, backend: Backend, diff --git a/qiskit_experiments/library/calibration/fine_amplitude.py b/qiskit_experiments/library/calibration/fine_amplitude.py index 27c020bc63..57dc010a44 100644 --- a/qiskit_experiments/library/calibration/fine_amplitude.py +++ b/qiskit_experiments/library/calibration/fine_amplitude.py @@ -12,10 +12,10 @@ """Fine amplitude calibration experiment.""" -from typing import Optional +from typing import List, Optional import numpy as np -from qiskit.circuit import Gate +from qiskit.circuit import Gate, QuantumCircuit from qiskit_experiments.calibration_management import ( BaseCalibrationExperiment, @@ -85,6 +85,34 @@ def _default_experiment_options(cls): return options + def _add_cal_metadata(self, circuits: List[QuantumCircuit]): + """Add metadata to the circuit to make the experiment data more self contained. + + The following keys are added to each circuit's metadata: + cal_param_value: The value of the pulse amplitude. This value together with + the fit result will be used to find the new value of the pulse amplitude. + cal_param_name: The name of the parameter in the calibrations. + cal_schedule: The name of the schedule in the calibrations. + target_angle: The target angle of the gate. + cal_group: The calibration group to which the parameter belongs. + """ + + param_val = self._cals.get_parameter_value( + self._param_name, + self._physical_qubits, + self._sched_name, + group=self.experiment_options.group, + ) + + for circuit in circuits: + circuit.metadata["cal_param_value"] = param_val + circuit.metadata["cal_param_name"] = self._param_name + circuit.metadata["cal_schedule"] = self._sched_name + circuit.metadata["target_angle"] = self.experiment_options.target_angle + circuit.metadata["cal_group"] = self.experiment_options.group + + return circuits + def update_calibrations(self, experiment_data: ExperimentData): r"""Update the amplitude of the pulse in the calibrations. @@ -100,27 +128,25 @@ def update_calibrations(self, experiment_data: ExperimentData): experiment_data: The experiment data from which to extract the measured over/under rotation used to adjust the amplitude. """ - result_index = self.experiment_options.result_index - group = self.experiment_options.group - target_angle = self.experiment_options.target_angle - - d_theta = BaseUpdater.get_value(experiment_data, "d_theta", result_index) - - prev_amp = self._cals.get_parameter_value( - self._param_name, - experiment_data.metadata["physical_qubits"], - self._sched_name, - group=group, - ) - - BaseUpdater.add_parameter_value( - self._cals, - experiment_data, - prev_amp * target_angle / (target_angle + d_theta), - self._param_name, - self._sched_name, - group, - ) + data = experiment_data.data() + + # No data -> no update + if len(data) > 0: + result_index = self.experiment_options.result_index + group = data[0]["metadata"]["cal_group"] + target_angle = data[0]["metadata"]["target_angle"] + prev_amp = data[0]["metadata"]["cal_param_value"] + + d_theta = BaseUpdater.get_value(experiment_data, "d_theta", result_index) + + BaseUpdater.add_parameter_value( + self._cals, + experiment_data, + prev_amp * target_angle / (target_angle + d_theta), + self._param_name, + self._sched_name, + group, + ) class FineXAmplitudeCal(FineAmplitudeCal): diff --git a/qiskit_experiments/library/characterization/fine_amplitude.py b/qiskit_experiments/library/characterization/fine_amplitude.py index 40392dc2c0..24815f66ba 100644 --- a/qiskit_experiments/library/characterization/fine_amplitude.py +++ b/qiskit_experiments/library/characterization/fine_amplitude.py @@ -54,13 +54,14 @@ class FineAmplitude(BaseExperiment): Error amplifying experiments are most sensitive to angle errors when we measure points along the equator of the Bloch sphere. This is why users should insert a square-root of X pulse before running calibrations for :math:`\pm\pi` rotations. When all data points are close to - the equator, it is difficult for a fitter to infer the overall scale of the error. When calibrating - a :math:`pi` rotation, one can use ``add_xp_circuit = True`` to insert one circuit that puts - the qubit in the excited state to set the scale for the other circuits. Furthermore, when - running calibrations for :math:`\pm\pi/2` rotations users are advised to use an odd - number of repetitions, e.g. [1, 2, 3, 5, 7, ...] to ensure that the ideal points are on the - equator of the Bloch sphere. Note the presence of two repetitions which allows us to - prepare the excited state. Therefore, ``add_xp_circuit = True`` is not needed in this case. + the equator, it is difficult for a fitter to infer the overall scale of the error. When + calibrating a :math:`pi` rotation, one can use ``add_xp_circuit = True`` to insert one + circuit that puts the qubit in the excited state to set the scale for the other circuits. + Furthermore, when running calibrations for :math:`\pm\pi/2` rotations users are advised + to use an odd number of repetitions, e.g. [1, 2, 3, 5, 7, ...] to ensure that the ideal + points are on the equator of the Bloch sphere. Note the presence of two repetitions which + allows us to prepare the excited state. Therefore, ``add_xp_circuit = True`` is not needed + in this case. # section: example