diff --git a/src/qibocal/auto/operation.py b/src/qibocal/auto/operation.py index 8b1f602eb..96e37ba15 100644 --- a/src/qibocal/auto/operation.py +++ b/src/qibocal/auto/operation.py @@ -159,6 +159,7 @@ def _to_npz(self, path: Path, filename: str): def _to_json(self, path: Path, filename: str): """Helper function to dump to json.""" if self.params: + print("AAAAAA", self.params) (path / f"{filename}.json").write_text( json.dumps(serialize(self.params), indent=4) ) diff --git a/src/qibocal/fitting/classifier/qubit_fit.py b/src/qibocal/fitting/classifier/qubit_fit.py index b5b95e0a4..61870ee3f 100644 --- a/src/qibocal/fitting/classifier/qubit_fit.py +++ b/src/qibocal/fitting/classifier/qubit_fit.py @@ -74,17 +74,17 @@ class QubitFit: probability_error: float = None effective_qubit_temperature: float = None - def fit(self, iq_coordinates: list, states: list): + def fit(self, i_coordinates: list, q_coordinates: list, states: list): r"""Evaluate the model's parameters given the `iq_coordinates` and their relative ``states` (reference: ). """ + iq_coordinates = np.stack((i_coordinates, q_coordinates), axis=-1) iq_state1 = iq_coordinates[(states == 1)] iq_state0 = iq_coordinates[(states == 0)] - self.iq_mean0 = np.mean(iq_state0, axis=0) - self.iq_mean1 = np.mean(iq_state1, axis=0) - - vector01 = self.iq_mean1 - self.iq_mean0 + iq_mean0 = np.mean(iq_state0, axis=0) + iq_mean1 = np.mean(iq_state1, axis=0) + vector01 = iq_mean1 - iq_mean0 self.angle = -1 * atan2(vector01[1], vector01[0]) # rotate @@ -115,6 +115,8 @@ def fit(self, iq_coordinates: list, states: list): self.probability_error = np.sum(np.absolute(states - predictions)) / len( predictions ) + self.iq_mean0 = iq_mean0.tolist() + self.iq_mean1 = iq_mean1.tolist() def effective_temperature(self, predictions, qubit_frequency: float): """Calculate effective qubit temperature.""" diff --git a/src/qibocal/fitting/classifier/run.py b/src/qibocal/fitting/classifier/run.py index cf962085f..b683867ef 100644 --- a/src/qibocal/fitting/classifier/run.py +++ b/src/qibocal/fitting/classifier/run.py @@ -242,7 +242,6 @@ def train_qubit( hpars_list.append(hyperpars) classifier.dump_hyper(hyperpars) model = classifier.create_model(hyperpars) - results, _y_pred, model, _ = benchmarking( model, x_train, y_train, x_test, y_test ) diff --git a/src/qibocal/protocols/classification.py b/src/qibocal/protocols/classification.py index 6731e08a0..fb6089134 100644 --- a/src/qibocal/protocols/classification.py +++ b/src/qibocal/protocols/classification.py @@ -1,29 +1,18 @@ -import json -import pathlib -from dataclasses import asdict, dataclass, field, fields -from typing import Optional +from dataclasses import dataclass, field import numpy as np import numpy.typing as npt -import pandas as pd -import plotly.graph_objects as go from qibolab import AcquisitionType, ExecutionParameters from qibolab.platform import Platform from qibolab.pulses import PulseSequence from qibolab.qubits import QubitId -from sklearn.metrics import roc_auc_score, roc_curve from qibocal import update -from qibocal.auto.operation import RESULTSFILE, Data, Parameters, Results, Routine -from qibocal.auto.serialize import serialize -from qibocal.fitting.classifier import run +from qibocal.auto.operation import Data, Parameters, Results, Routine +from qibocal.fitting.classifier.qubit_fit import QubitFit from qibocal.protocols.utils import ( - LEGEND_FONT_SIZE, - MESH_SIZE, - TITLE_SIZE, evaluate_grid, format_error_single_cell, - get_color_state0, plot_results, round_report, table_dict, @@ -42,12 +31,6 @@ class SingleShotClassificationParameters(Parameters): unrolling: bool = False """If ``True`` it uses sequence unrolling to deploy multiple sequences in a single instrument call. Defaults to ``False``.""" - classifiers_list: Optional[list[str]] = field( - default_factory=lambda: [DEFAULT_CLASSIFIER] - ) - """List of models to classify the qubit states""" - savedir: Optional[str] = " " - """Dumping folder of the classification results""" ClassificationType = np.dtype([("i", np.float64), ("q", np.float64), ("state", int)]) @@ -58,28 +41,16 @@ class SingleShotClassificationParameters(Parameters): class SingleShotClassificationData(Data): nshots: int """Number of shots.""" - savedir: str - """Dumping folder of the classification results""" qubit_frequencies: dict[QubitId, float] = field(default_factory=dict) """Qubit frequencies.""" data: dict[QubitId, npt.NDArray] = field(default_factory=dict) """Raw data acquired.""" - classifiers_list: Optional[list[str]] = field( - default_factory=lambda: [DEFAULT_CLASSIFIER] - ) - """List of models to classify the qubit states""" @dataclass class SingleShotClassificationResults(Results): """SingleShotClassification outputs.""" - names: list - """List of models name.""" - savedir: str - """Dumping folder of the classification results.""" - y_preds: dict[QubitId, list] - """Models' predictions of the test set.""" grid_preds: dict[QubitId, list] """Models' prediction of the contour grid.""" threshold: dict[QubitId, float] = field(default_factory=dict) @@ -96,48 +67,6 @@ class SingleShotClassificationResults(Results): """Assignment fidelity evaluated only with the `qubit_fit` model.""" effective_temperature: dict[QubitId, float] = field(default_factory=dict) """Qubit effective temperature from Boltzmann distribution.""" - models: dict[QubitId, list] = field(default_factory=list) - """List of trained classification models.""" - benchmark_table: Optional[dict[QubitId, pd.DataFrame]] = field(default_factory=dict) - """Benchmark tables.""" - classifiers_hpars: Optional[dict[QubitId, dict]] = field(default_factory=dict) - """Classifiers hyperparameters.""" - x_tests: dict[QubitId, list] = field(default_factory=dict) - """Test set.""" - y_tests: dict[QubitId, list] = field(default_factory=dict) - """Test set.""" - - def __contains__(self, key: QubitId): - """Checking if key is in Results. - - Overwritten because classifiers_hpars is empty when running - the default_classifier. - """ - return all( - key in getattr(self, field.name) - for field in fields(self) - if isinstance(getattr(self, field.name), dict) - and field.name != "classifiers_hpars" - ) - - def save(self, path): - classifiers = run.import_classifiers(self.names) - for qubit in self.models: - for i, mod in enumerate(classifiers): - if self.savedir == " ": - save_path = pathlib.Path(path) - else: - save_path = pathlib.Path(self.savedir) - - classifier = run.Classifier(mod, save_path / f"qubit{qubit}") - classifier.savedir.mkdir(parents=True, exist_ok=True) - dump_dir = classifier.base_dir / classifier.name / classifier.name - classifier.dump()(self.models[qubit][i], dump_dir) - classifier.dump_hyper(self.classifiers_hpars[qubit][classifier.name]) - asdict_class = asdict(self) - asdict_class.pop("models") - asdict_class.pop("classifiers_hpars") - (path / f"{RESULTSFILE}.json").write_text(json.dumps(serialize(asdict_class))) def _acquisition( @@ -164,7 +93,6 @@ def _acquisition( parameters: nshots: 5000 savedir: "single_shot" - classifiers_list: ["qubit_fit"] """ @@ -190,15 +118,6 @@ def _acquisition( sequences.append(sequence) all_ro_pulses.append(ro_pulses) - data = SingleShotClassificationData( - nshots=params.nshots, - qubit_frequencies={ - qubit: platform.qubits[qubit].drive_frequency for qubit in targets - }, - classifiers_list=params.classifiers_list, - savedir=params.savedir, - ) - options = ExecutionParameters( nshots=params.nshots, relaxation_time=params.relaxation_time, @@ -212,6 +131,12 @@ def _acquisition( platform.execute_pulse_sequence(sequence, options) for sequence in sequences ] + data = SingleShotClassificationData( + nshots=params.nshots, + qubit_frequencies={ + qubit: platform.qubits[qubit].drive_frequency for qubit in targets + }, + ) for ig, (state, ro_pulses) in enumerate(zip([0, 1], all_ro_pulses)): for qubit in targets: serial = ro_pulses[qubit].serial @@ -232,69 +157,49 @@ def _acquisition( return data +def train_classifier(data, qubit): + qubit_data = data.data[qubit] + i_values = qubit_data["i"] + q_values = qubit_data["q"] + states = qubit_data["state"] + model = QubitFit() + model.fit(i_values, q_values, states) + return model + + def _fit(data: SingleShotClassificationData) -> SingleShotClassificationResults: qubits = data.qubits - benchmark_tables = {} - models_dict = {} - y_tests = {} - x_tests = {} - hpars = {} threshold = {} rotation_angle = {} mean_gnd_states = {} mean_exc_states = {} fidelity = {} assignment_fidelity = {} - y_test_predict = {} grid_preds_dict = {} effective_temperature = {} for qubit in qubits: qubit_data = data.data[qubit] - state0_data = qubit_data[qubit_data.state == 0] - iq_state0 = state0_data[["i", "q"]] - benchmark_table, y_test, x_test, models, names, hpars_list = run.train_qubit( - data, qubit - ) - benchmark_tables[qubit] = benchmark_table.values.tolist() - models_dict[qubit] = models - y_tests[qubit] = y_test.tolist() - x_tests[qubit] = x_test.tolist() - hpars[qubit] = {} - y_preds = [] - grid_preds = [] + i_values = qubit_data["i"] + q_values = qubit_data["q"] + iq_values = np.stack((i_values, q_values), axis=-1) + states = qubit_data["state"] + model = train_classifier(data, qubit) grid = evaluate_grid(qubit_data) - for i, model_name in enumerate(names): - hpars[qubit][model_name] = hpars_list[i] - try: - y_preds.append(models[i].predict_proba(x_test)[:, 1].tolist()) - except AttributeError: - y_preds.append(models[i].predict(x_test).tolist()) - grid_preds.append( - np.round(np.reshape(models[i].predict(grid), (MESH_SIZE, MESH_SIZE))) - .astype(np.int64) - .tolist() - ) - if model_name == "qubit_fit": - threshold[qubit] = models[i].threshold - rotation_angle[qubit] = models[i].angle - mean_gnd_states[qubit] = models[i].iq_mean0.tolist() - mean_exc_states[qubit] = models[i].iq_mean1.tolist() - fidelity[qubit] = models[i].fidelity - assignment_fidelity[qubit] = models[i].assignment_fidelity - predictions_state0 = models[i].predict(iq_state0.tolist()) - effective_temperature[qubit] = models[i].effective_temperature( - predictions_state0, data.qubit_frequencies[qubit] - ) - y_test_predict[qubit] = y_preds - grid_preds_dict[qubit] = grid_preds + grid_preds = model.predict(grid) + threshold[qubit] = model.threshold + rotation_angle[qubit] = model.angle + mean_gnd_states[qubit] = model.iq_mean0 + mean_exc_states[qubit] = model.iq_mean1 + fidelity[qubit] = model.fidelity + assignment_fidelity[qubit] = model.assignment_fidelity + iq_state0 = iq_values[states == 0] + predictions_state0 = model.predict(iq_state0.tolist()) + effective_temperature[qubit] = model.effective_temperature( + predictions_state0, data.qubit_frequencies[qubit] + ) + grid_preds_dict[qubit] = grid_preds.tolist() return SingleShotClassificationResults( - benchmark_table=benchmark_tables, - y_tests=y_tests, - x_tests=x_tests, - names=names, - classifiers_hpars=hpars, - models=models_dict, threshold=threshold, rotation_angle=rotation_angle, mean_gnd_states=mean_gnd_states, @@ -302,8 +207,6 @@ def _fit(data: SingleShotClassificationData) -> SingleShotClassificationResults: fidelity=fidelity, assignment_fidelity=assignment_fidelity, effective_temperature=effective_temperature, - savedir=data.savedir, - y_preds=y_test_predict, grid_preds=grid_preds_dict, ) @@ -314,74 +217,33 @@ def _plot( fit: SingleShotClassificationResults, ): fitting_report = "" - models_name = data.classifiers_list figures = plot_results(data, target, 2, fit) if fit is not None: - y_test = fit.y_tests[target] - y_pred = fit.y_preds[target] - - if len(models_name) != 1: - # Evaluate the ROC curve - fig_roc = go.Figure() - fig_roc.add_shape( - type="line", line=dict(dash="dash"), x0=0.0, x1=1.0, y0=0.0, y1=1.0 - ) - for i, model in enumerate(models_name): - y_pred = fit.y_preds[target][i] - fpr, tpr, _ = roc_curve(y_test, y_pred) - auc_score = roc_auc_score(y_test, y_pred) - name = f"{model} (AUC={auc_score:.2f})" - fig_roc.add_trace( - go.Scatter( - x=fpr, - y=tpr, - name=name, - mode="lines", - marker=dict(size=3, color=get_color_state0(i)), - ) - ) - fig_roc.update_layout( - width=ROC_WIDTH, - height=ROC_LENGHT, - title=dict(text="ROC curves", font=dict(size=TITLE_SIZE)), - legend=dict(font=dict(size=LEGEND_FONT_SIZE)), - ) - fig_roc.update_xaxes( - title_text=f"False Positive Rate", - range=[0, 1], - ) - fig_roc.update_yaxes( - title_text="True Positive Rate", - range=[0, 1], - ) - figures.append(fig_roc) - - if "qubit_fit" in models_name: - fitting_report = table_html( - table_dict( - target, - [ - "Average State 0", - "Average State 1", - "Rotational Angle", - "Threshold", - "Readout Fidelity", - "Assignment Fidelity", - "Effective Qubit Temperature [K]", - ], - [ - np.round(fit.mean_gnd_states[target], 3), - np.round(fit.mean_exc_states[target], 3), - np.round(fit.rotation_angle[target], 3), - np.round(fit.threshold[target], 6), - np.round(fit.fidelity[target], 3), - np.round(fit.assignment_fidelity[target], 3), - format_error_single_cell( - round_report([fit.effective_temperature[target]]) - ), - ], - ) + fitting_report = table_html( + table_dict( + target, + [ + "Average State 0", + "Average State 1", + "Rotational Angle", + "Threshold", + "Readout Fidelity", + "Assignment Fidelity", + "Effective Qubit Temperature [K]", + ], + [ + np.round(fit.mean_gnd_states[target], 3), + np.round(fit.mean_exc_states[target], 3), + np.round(fit.rotation_angle[target], 3), + np.round(fit.threshold[target], 6), + np.round(fit.fidelity[target], 3), + np.round(fit.assignment_fidelity[target], 3), + format_error_single_cell( + round_report([fit.effective_temperature[target]]) + ), + ], ) + ) return figures, fitting_report diff --git a/src/qibocal/protocols/qutrit_classification.py b/src/qibocal/protocols/qutrit_classification.py index fdb3fecaa..14e0c930e 100644 --- a/src/qibocal/protocols/qutrit_classification.py +++ b/src/qibocal/protocols/qutrit_classification.py @@ -1,5 +1,4 @@ -from dataclasses import dataclass, field -from typing import Optional +from dataclasses import dataclass from qibolab import AcquisitionType, ExecutionParameters from qibolab.platform import Platform @@ -28,16 +27,15 @@ class QutritClassificationParameters(SingleShotClassificationParameters): @dataclass class QutritClassificationData(SingleShotClassificationData): - classifiers_list: Optional[list[str]] = field( - default_factory=lambda: [DEFAULT_CLASSIFIER] - ) - """List of models to classify the qubit states""" + pass @dataclass class QutritClassificationResults(Results): """Qutrit classification results""" + pass + def _acquisition( params: QutritClassificationParameters, @@ -50,11 +48,6 @@ def _acquisition( Args: nshots (int): number of times the pulse sequence will be repeated. - classifiers (list): list of classifiers, the available ones are: - - naive_bayes - - nn - - random_forest - - decision_tree The default value is `["naive_bayes"]`. savedir (str): Dumping folder of the classification results. If not given, the dumping folder will be the report one. @@ -79,8 +72,6 @@ def _acquisition( data = QutritClassificationData( nshots=params.nshots, - classifiers_list=params.classifiers_list, - savedir=params.savedir, ) states_results = [] for sequence in states_sequences: diff --git a/src/qibocal/protocols/readout_optimization/resonator_amplitude.py b/src/qibocal/protocols/readout_optimization/resonator_amplitude.py index 6826d2757..9a9a0e3ac 100644 --- a/src/qibocal/protocols/readout_optimization/resonator_amplitude.py +++ b/src/qibocal/protocols/readout_optimization/resonator_amplitude.py @@ -1,18 +1,16 @@ from dataclasses import dataclass, field -from os import error import numpy as np import numpy.typing as npt import plotly.graph_objects as go from plotly.subplots import make_subplots -from qibolab import AcquisitionType, ExecutionParameters from qibolab.platform import Platform -from qibolab.pulses import PulseSequence from qibolab.qubits import QubitId from qibocal import update from qibocal.auto.operation import Data, Parameters, Results, Routine -from qibocal.fitting.classifier.qubit_fit import QubitFit +from qibocal.protocols.classification import _acquisition as cl_acq +from qibocal.protocols.classification import train_classifier from qibocal.protocols.utils import table_dict, table_html @@ -32,6 +30,8 @@ class ResonatorAmplitudeParameters(Parameters): ResonatorAmplitudeType = np.dtype( [ + ("i_values", np.float64), + ("q_values", np.float64), ("error", np.float64), ("amp", np.float64), ("angle", np.float64), @@ -85,60 +85,25 @@ def _acquisition( data = ResonatorAmplitudeData() for qubit in targets: error = 1 - old_amp = platform.qubits[qubit].native_gates.MZ.amplitude new_amp = params.amplitude_start while error > params.error_threshold and new_amp <= params.amplitude_stop: platform.qubits[qubit].native_gates.MZ.amplitude = new_amp - sequence_0 = PulseSequence() - sequence_1 = PulseSequence() - - qd_pulses = platform.create_RX_pulse(qubit, start=0) - ro_pulses = platform.create_qubit_readout_pulse( - qubit, start=qd_pulses.finish - ) - sequence_0.add(ro_pulses) - sequence_1.add(qd_pulses) - sequence_1.add(ro_pulses) - - state0_results = platform.execute_pulse_sequence( - sequence_0, - ExecutionParameters( - nshots=params.nshots, - relaxation_time=params.relaxation_time, - acquisition_type=AcquisitionType.INTEGRATION, - ), - ) - - state1_results = platform.execute_pulse_sequence( - sequence_1, - ExecutionParameters( - nshots=params.nshots, - relaxation_time=params.relaxation_time, - acquisition_type=AcquisitionType.INTEGRATION, - ), - ) - result0 = state0_results[ro_pulses.serial] - result1 = state1_results[ro_pulses.serial] - - i_values = np.concatenate((result0.voltage_i, result1.voltage_i)) - q_values = np.concatenate((result0.voltage_q, result1.voltage_q)) - iq_values = np.stack((i_values, q_values), axis=-1) - nshots = int(len(i_values) / 2) - states = [0] * nshots + [1] * nshots - model = QubitFit() - model.fit(iq_values, np.array(states)) + params.unrolling = False + cl_data = cl_acq(params, platform, targets) + model = train_classifier(cl_data, qubit) error = model.probability_error data.register_qubit( ResonatorAmplitudeType, (qubit), dict( + i_values=cl_data.data[qubit]["i"], + q_values=cl_data.data[qubit]["q"], amp=np.array([new_amp]), error=np.array([error]), angle=np.array([model.angle]), threshold=np.array([model.threshold]), ), ) - platform.qubits[qubit].native_gates.MZ.amplitude = old_amp new_amp += params.amplitude_step return data diff --git a/src/qibocal/protocols/readout_optimization/resonator_frequency.py b/src/qibocal/protocols/readout_optimization/resonator_frequency.py index c9a27609f..fde31b653 100644 --- a/src/qibocal/protocols/readout_optimization/resonator_frequency.py +++ b/src/qibocal/protocols/readout_optimization/resonator_frequency.py @@ -146,7 +146,7 @@ def _acquisition( states.extend([i] * len(result.voltage_i[:, k])) model = QubitFit() - model.fit(np.stack((i_values, q_values), axis=-1), np.array(states)) + model.fit(i_values, q_values, np.array(states)) data.register_qubit( ResonatorFrequencyType, (qubit), diff --git a/src/qibocal/protocols/utils.py b/src/qibocal/protocols/utils.py index c806e5679..9f3289a57 100644 --- a/src/qibocal/protocols/utils.py +++ b/src/qibocal/protocols/utils.py @@ -14,7 +14,6 @@ from qibocal.auto.operation import Data, Results from qibocal.config import log -from qibocal.fitting.classifier import run from qibocal.protocols.resonator_utils import ( cable_delay, circle_fit, @@ -1044,39 +1043,33 @@ def plot_results(data: Data, qubit: QubitId, qubit_states: list, fit: Results): fit (Results): fit results """ figures = [] - models_name = data.classifiers_list qubit_data = data.data[qubit] - grid = evaluate_grid(qubit_data) fig = make_subplots( rows=1, - cols=len(models_name), - horizontal_spacing=SPACING * 3 / len(models_name) * 3, - vertical_spacing=SPACING, - subplot_titles=[run.pretty_name(model) for model in models_name], - column_width=[COLUMNWIDTH] * len(models_name), + cols=1, ) - for i, model in enumerate(models_name): - if fit is not None: - predictions = fit.grid_preds[qubit][i] - fig.add_trace( - go.Contour( - x=grid[:, 0], - y=grid[:, 1], - z=np.array(predictions).flatten(), - showscale=False, - colorscale=[get_color_state0(i), get_color_state1(i)], - opacity=0.2, - name="Score", - hoverinfo="skip", - showlegend=True, - ), - row=1, - col=i + 1, - ) + if fit is not None: + grid = evaluate_grid(qubit_data) + predictions = fit.grid_preds[qubit] + fig.add_trace( + go.Contour( + x=grid[:, 0], + y=grid[:, 1], + z=np.array(predictions).flatten(), + showscale=False, + colorscale=[get_color_state0(0), get_color_state1(0)], + opacity=0.2, + name="Score", + hoverinfo="skip", + showlegend=True, + ), + row=1, + col=1, + ) - model = run.pretty_name(model) + model = "qubit fit" # run.pretty_name(model) max_x = max(grid[:, 0]) max_y = max(grid[:, 1]) min_x = min(grid[:, 0]) @@ -1097,7 +1090,7 @@ def plot_results(data: Data, qubit: QubitId, qubit_states: list, fit: Results): marker=dict(size=3), ), row=1, - col=i + 1, + col=1, ) fig.add_trace( @@ -1111,14 +1104,14 @@ def plot_results(data: Data, qubit: QubitId, qubit_states: list, fit: Results): marker=dict(size=10), ), row=1, - col=i + 1, + col=1, ) fig.update_xaxes( title_text=f"i [a.u.]", range=[min_x, max_x], row=1, - col=i + 1, + col=1, autorange=False, rangeslider=dict(visible=False), ) @@ -1128,14 +1121,12 @@ def plot_results(data: Data, qubit: QubitId, qubit_states: list, fit: Results): scaleanchor="x", scaleratio=1, row=1, - col=i + 1, + col=1, ) fig.update_layout( autosize=False, - height=COLUMNWIDTH, - width=COLUMNWIDTH * len(models_name), - title=dict(text="Results", font=dict(size=TITLE_SIZE)), + title=dict(text="Results"), legend=dict( orientation="h", yanchor="bottom", @@ -1147,44 +1138,6 @@ def plot_results(data: Data, qubit: QubitId, qubit_states: list, fit: Results): ), ) figures.append(fig) - - if fit is not None and len(models_name) != 1: - fig_benchmarks = make_subplots( - rows=1, - cols=3, - horizontal_spacing=SPACING, - vertical_spacing=SPACING, - subplot_titles=( - "accuracy", - "testing time [s]", - "training time [s]", - ), - # pylint: disable=E1101 - ) - for i, model in enumerate(models_name): - for plot in range(3): - fig_benchmarks.add_trace( - go.Scatter( - x=[model], - y=[fit.benchmark_table[qubit][i][plot]], - mode="markers", - showlegend=False, - marker=dict(size=10, color=get_color_state1(i)), - ), - row=1, - col=plot + 1, - ) - - fig_benchmarks.update_yaxes(type="log", row=1, col=2) - fig_benchmarks.update_yaxes(type="log", row=1, col=3) - fig_benchmarks.update_layout( - autosize=False, - height=COLUMNWIDTH, - width=COLUMNWIDTH * 3, - title=dict(text="Benchmarks", font=dict(size=TITLE_SIZE)), - ) - - figures.append(fig_benchmarks) return figures diff --git a/tests/runcards/protocols.yml b/tests/runcards/protocols.yml index 5fb92f1fa..53c4875f3 100644 --- a/tests/runcards/protocols.yml +++ b/tests/runcards/protocols.yml @@ -516,13 +516,6 @@ actions: unrolling: True nshots: 10 - - id: single shot classification with classifiers - operation: single_shot_classification - parameters: - nshots: 10 - savedir: "cls_results" - classifiers_list: ["qubit_fit"] - - id: readout characterization operation: readout_characterization parameters: