cirq-core 1.3.0.dev20231201141002__py3-none-any.whl → 1.4.0__py3-none-any.whl

cirq/experiments/single_qubit_readout_calibration.py

@@ -18,6 +18,10 @@ from typing import Any, Dict, Iterable, List, Optional, TYPE_CHECKING
 
 import sympy
 import numpy as np
+import matplotlib.pyplot as plt
+import cirq.vis.heatmap as cirq_heatmap
+import cirq.vis.histogram as cirq_histogram
+from cirq.devices import grid_qubit
 from cirq import circuits, ops, study
 
 if TYPE_CHECKING:
@@ -51,6 +55,124 @@ class SingleQubitReadoutCalibrationResult:
             'timestamp': self.timestamp,
         }
 
+    def plot_heatmap(
+        self,
+        axs: Optional[tuple[plt.Axes, plt.Axes]] = None,
+        annotation_format: str = '0.1%',
+        **plot_kwargs: Any,
+    ) -> tuple[plt.Axes, plt.Axes]:
+        """Plot a heatmap of the readout errors. If qubits are not cirq.GridQubits, throws an error.
+
+        Args:
+            axs: a tuple of the plt.Axes to plot on. If not given, a new figure is created,
+                plotted on, and shown.
+            annotation_format: The format string for the numbers in the heatmap.
+            **plot_kwargs: Arguments to be passed to 'cirq.Heatmap.plot()'.
+        Returns:
+            The two plt.Axes containing the plot.
+
+        Raises:
+            ValueError: axs does not contain two plt.Axes
+            TypeError: qubits are not cirq.GridQubits
+        """
+
+        if axs is None:
+            _, axs = plt.subplots(1, 2, dpi=200, facecolor='white', figsize=(12, 4))
+
+        else:
+            if (
+                not isinstance(axs, (tuple, list, np.ndarray))
+                or len(axs) != 2
+                or type(axs[0]) != plt.Axes
+                or type(axs[1]) != plt.Axes
+            ):  # pragma: no cover
+                raise ValueError('axs should be a length-2 tuple of plt.Axes')  # pragma: no cover
+        for ax, title, data in zip(
+            axs,
+            ['$|0\\rangle$ errors', '$|1\\rangle$ errors'],
+            [self.zero_state_errors, self.one_state_errors],
+        ):
+            data_with_grid_qubit_keys = {}
+            for qubit in data:
+                if type(qubit) != grid_qubit.GridQubit:
+                    raise TypeError(f'{qubit} must be of type cirq.GridQubit')  # pragma: no cover
+                data_with_grid_qubit_keys[qubit] = data[qubit]  # just for typecheck
+            _, _ = cirq_heatmap.Heatmap(data_with_grid_qubit_keys).plot(
+                ax, annotation_format=annotation_format, title=title, **plot_kwargs
+            )
+        return axs[0], axs[1]
+
+    def plot_integrated_histogram(
+        self,
+        ax: Optional[plt.Axes] = None,
+        cdf_on_x: bool = False,
+        axis_label: str = 'Readout error rate',
+        semilog: bool = True,
+        median_line: bool = True,
+        median_label: Optional[str] = 'median',
+        mean_line: bool = False,
+        mean_label: Optional[str] = 'mean',
+        show_zero: bool = False,
+        title: Optional[str] = None,
+        **kwargs,
+    ) -> plt.Axes:
+        """Plot the readout errors using cirq.integrated_histogram().
+
+        Args:
+            ax: The axis to plot on. If None, we generate one.
+            cdf_on_x: If True, flip the axes compared the above example.
+            axis_label: Label for x axis (y-axis if cdf_on_x is True).
+            semilog: If True, force the x-axis to be logarithmic.
+            median_line: If True, draw a vertical line on the median value.
+            median_label: If drawing median line, optional label for it.
+            mean_line: If True, draw a vertical line on the mean value.
+            mean_label: If drawing mean line, optional label for it.
+            title: Title of the plot. If None, we assign "N={len(data)}".
+            show_zero: If True, moves the step plot up by one unit by prepending 0
+                to the data.
+            **kwargs: Kwargs to forward to `ax.step()`. Some examples are
+                color: Color of the line.
+                linestyle: Linestyle to use for the plot.
+                lw: linewidth for integrated histogram.
+                ms: marker size for a histogram trace.
+        Returns:
+            The axis that was plotted on.
+        """
+
+        ax = cirq_histogram.integrated_histogram(
+            data=self.zero_state_errors,
+            ax=ax,
+            cdf_on_x=cdf_on_x,
+            semilog=semilog,
+            median_line=median_line,
+            median_label=median_label,
+            mean_line=mean_line,
+            mean_label=mean_label,
+            show_zero=show_zero,
+            color='C0',
+            label='$|0\\rangle$ errors',
+            **kwargs,
+        )
+        ax = cirq_histogram.integrated_histogram(
+            data=self.one_state_errors,
+            ax=ax,
+            cdf_on_x=cdf_on_x,
+            axis_label=axis_label,
+            semilog=semilog,
+            median_line=median_line,
+            median_label=median_label,
+            mean_line=mean_line,
+            mean_label=mean_label,
+            show_zero=show_zero,
+            title=title,
+            color='C1',
+            label='$|1\\rangle$ errors',
+            **kwargs,
+        )
+        ax.legend(loc='best')
+        ax.set_ylabel('Percentile')
+        return ax
+
     @classmethod
     def _from_json_dict_(
         cls, zero_state_errors, one_state_errors, repetitions, timestamp, **kwargs
@@ -221,15 +343,19 @@ def estimate_parallel_single_qubit_readout_errors(
             trial_idx += 1
 
     zero_state_errors = {
-        q: zero_state_trials[0][qubit_idx] / zero_state_totals[0][qubit_idx]
-        if zero_state_totals[0][qubit_idx] > 0
-        else np.nan
+        q: (
+            zero_state_trials[0][qubit_idx] / zero_state_totals[0][qubit_idx]
+            if zero_state_totals[0][qubit_idx] > 0
+            else np.nan
+        )
         for qubit_idx, q in enumerate(qubits)
     }
     one_state_errors = {
-        q: one_state_trials[0][qubit_idx] / one_state_totals[0][qubit_idx]
-        if one_state_totals[0][qubit_idx] > 0
-        else np.nan
+        q: (
+            one_state_trials[0][qubit_idx] / one_state_totals[0][qubit_idx]
+            if one_state_totals[0][qubit_idx] > 0
+            else np.nan
+        )
         for qubit_idx, q in enumerate(qubits)
     }
 

cirq/experiments/single_qubit_readout_calibration_test.py

@@ -87,7 +87,7 @@ def test_estimate_single_qubit_readout_errors_with_noise():
 
 
 def test_estimate_parallel_readout_errors_no_noise():
-    qubits = cirq.LineQubit.range(10)
+    qubits = [cirq.GridQubit(i, 0) for i in range(10)]
     sampler = cirq.Simulator()
     repetitions = 1000
     result = cirq.estimate_parallel_single_qubit_readout_errors(
@@ -97,6 +97,8 @@ def test_estimate_parallel_readout_errors_no_noise():
     assert result.one_state_errors == {q: 0 for q in qubits}
     assert result.repetitions == repetitions
     assert isinstance(result.timestamp, float)
+    _ = result.plot_integrated_histogram()
+    _, _ = result.plot_heatmap()
 
 
 def test_estimate_parallel_readout_errors_all_zeros():

cirq/experiments/t1_decay_experiment.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Optional, TYPE_CHECKING
+from typing import Any, Optional, Sequence, TYPE_CHECKING, cast
 
 import warnings
 import pandas as pd
@@ -77,7 +77,12 @@ def t1_decay(
 
     var = sympy.Symbol('delay_ns')
 
-    sweep = study.Linspace(var, start=min_delay_nanos, stop=max_delay_nanos, length=num_points)
+    if min_delay_nanos == 0:
+        min_delay_nanos = 0.4
+    sweep_vals_ns = np.unique(
+        np.round(np.logspace(np.log10(min_delay_nanos), np.log10(max_delay_nanos), num_points))
+    )
+    sweep = study.Points(var, cast(Sequence[float], sweep_vals_ns))
 
     circuit = circuits.Circuit(
         ops.X(qubit), ops.wait(qubit, nanos=var), ops.measure(qubit, key='output')
@@ -118,8 +123,8 @@ class T1DecayResult:
     def constant(self) -> float:
         """The t1 decay constant."""
 
-        def exp_decay(x, t1):
-            return np.exp(-x / t1)
+        def exp_decay(x, t1, a, b):
+            return a * np.exp(-x / t1) + b
 
         xs = self._data['delay_ns']
         ts = self._data['true_count']
@@ -132,8 +137,8 @@ class T1DecayResult:
 
         # Fit to exponential decay to find the t1 constant
         try:
-            popt, _ = optimize.curve_fit(exp_decay, xs, probs, p0=[t1_guess])
-            t1 = popt[0]
+            self.popt, _ = optimize.curve_fit(exp_decay, xs, probs, p0=[t1_guess, 1.0, 0.0])
+            t1 = self.popt[0]
             return t1
         except RuntimeError:
             warnings.warn("Optimal parameters could not be found for curve fit", RuntimeWarning)
@@ -166,7 +171,9 @@ class T1DecayResult:
         ax.plot(xs, ts / (fs + ts), 'ro-', **plot_kwargs)
 
         if include_fit and not np.isnan(self.constant):
-            ax.plot(xs, np.exp(-xs / self.constant), label='curve fit')
+            t1 = self.constant
+            t1, a, b = self.popt
+            ax.plot(xs, a * np.exp(-xs / t1) + b, label='curve fit')
             plt.legend()
 
         ax.set_xlabel(r"Delay between initialization and measurement (nanoseconds)")

cirq/experiments/t1_decay_experiment_test.py

@@ -53,7 +53,7 @@ def test_plot_does_not_raise_error():
         repetitions=10,
         max_delay=cirq.Duration(nanos=500),
     )
-    results.plot()
+    results.plot(include_fit=True)
 
 
 def test_result_eq():
@@ -61,7 +61,7 @@ def test_result_eq():
     eq.make_equality_group(
         lambda: cirq.experiments.T1DecayResult(
             data=pd.DataFrame(
-                columns=['delay_ns', 'false_count', 'true_count'], index=[0], data=[[100.0, 2, 8]]
+                columns=['delay_ns', 'false_count', 'true_count'], index=[0], data=[[100, 2, 8]]
             )
         )
     )
@@ -103,7 +103,7 @@ def test_sudden_decay_results():
         data=pd.DataFrame(
             columns=['delay_ns', 'false_count', 'true_count'],
             index=range(4),
-            data=[[100.0, 0, 10], [400.0, 0, 10], [700.0, 10, 0], [1000.0, 10, 0]],
+            data=[[100.0, 0, 10], [215.0, 0, 10], [464.0, 0, 10], [1000.0, 10, 0]],
         )
     )
 
@@ -117,13 +117,14 @@ def test_all_on_results():
         min_delay=cirq.Duration(nanos=100),
         max_delay=cirq.Duration(micros=1),
     )
-    assert results == cirq.experiments.T1DecayResult(
+    desired = cirq.experiments.T1DecayResult(
         data=pd.DataFrame(
             columns=['delay_ns', 'false_count', 'true_count'],
             index=range(4),
-            data=[[100.0, 0, 10], [400.0, 0, 10], [700.0, 0, 10], [1000.0, 0, 10]],
+            data=[[100.0, 0, 10], [215.0, 0, 10], [464.0, 0, 10], [1000.0, 0, 10]],
         )
     )
+    assert results == desired, f'{results.data=} {desired.data=}'
 
 
 def test_all_off_results():
@@ -135,13 +136,14 @@ def test_all_off_results():
         min_delay=cirq.Duration(nanos=100),
         max_delay=cirq.Duration(micros=1),
     )
-    assert results == cirq.experiments.T1DecayResult(
+    desired = cirq.experiments.T1DecayResult(
         data=pd.DataFrame(
             columns=['delay_ns', 'false_count', 'true_count'],
             index=range(4),
-            data=[[100.0, 10, 0], [400.0, 10, 0], [700.0, 10, 0], [1000.0, 10, 0]],
+            data=[[100.0, 10, 0], [215.0, 10, 0], [464.0, 10, 0], [1000.0, 10, 0]],
         )
     )
+    assert results == desired, f'{results.data=} {desired.data=}'
 
 
 @pytest.mark.usefixtures('closefigures')
@@ -150,28 +152,14 @@ def test_curve_fit_plot_works():
         data=pd.DataFrame(
             columns=['delay_ns', 'false_count', 'true_count'],
             index=range(4),
-            data=[[100.0, 6, 4], [400.0, 10, 0], [700.0, 10, 0], [1000.0, 10, 0]],
+            data=[[100.0, 6, 4], [215.0, 10, 0], [464.0, 10, 0], [1000.0, 10, 0]],
         )
     )
 
     good_fit.plot(include_fit=True)
 
 
-@pytest.mark.usefixtures('closefigures')
-def test_curve_fit_plot_warning():
-    bad_fit = cirq.experiments.T1DecayResult(
-        data=pd.DataFrame(
-            columns=['delay_ns', 'false_count', 'true_count'],
-            index=range(4),
-            data=[[100.0, 10, 0], [400.0, 10, 0], [700.0, 10, 0], [1000.0, 10, 0]],
-        )
-    )
-
-    with pytest.warns(RuntimeWarning, match='Optimal parameters could not be found for curve fit'):
-        bad_fit.plot(include_fit=True)
-
-
-@pytest.mark.parametrize('t1', [200, 500, 700])
+@pytest.mark.parametrize('t1', [200.0, 500.0, 700.0])
 def test_noise_model_continous(t1):
     class GradualDecay(cirq.NoiseModel):
         def __init__(self, t1: float):
@@ -196,10 +184,10 @@ def test_noise_model_continous(t1):
     results = cirq.experiments.t1_decay(
         sampler=cirq.DensityMatrixSimulator(noise=GradualDecay(t1)),
         qubit=cirq.GridQubit(0, 0),
-        num_points=4,
+        num_points=10,
         repetitions=10,
-        min_delay=cirq.Duration(nanos=100),
-        max_delay=cirq.Duration(micros=1),
+        min_delay=cirq.Duration(nanos=1),
+        max_delay=cirq.Duration(micros=10),
     )
 
     assert np.isclose(results.constant, t1, 50)