Classifiers

runcards/actions_qq.yml

@@ -227,7 +227,9 @@ actions:
 #     priority: 0
 #     operation: single_shot_classification
 #     parameters:
-#       nshots: 10
+#       nshots: 2000
+#       classifiers_list: ["qubit_fit", "naive_bayes", "qblox_fit"]
+#       savedir: results
 
 
 #   - id: allXY

src/qibocal/fitting/classifier/ada_boost.py

@@ -0,0 +1,42 @@
+import numpy as np
+from sklearn.ensemble import AdaBoostClassifier
+from sklearn.model_selection import GridSearchCV, RepeatedStratifiedKFold
+
+from . import scikit_utils
+
+
+def constructor(hyperpars):
+    r"""Return the model class.
+
+    Args:
+        hyperparams: Model hyperparameters.
+    """
+    return AdaBoostClassifier().set_params(**hyperpars)
+
+
+def hyperopt(x_train, y_train, _path):
+    r"""Perform an hyperparameter optimization and return the hyperparameters.
+
+    Args:
+        x_train: Training inputs.
+        y_train: Training outputs.
+        _path (path): Model save path.
+
+    Returns:
+        Dictionary with model's hyperparameters.
+    """
+    clf = AdaBoostClassifier()
+    cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
+    space = {}
+    space["n_estimators"] = np.linspace(10, 200, num=20).astype("int")
+    space["learning_rate"] = np.linspace(0.1, 1, num=10)
+    space["algorithm"] = ["SAMME", "SAMME.R"]
+    search = GridSearchCV(clf, space, scoring="accuracy", n_jobs=-1, cv=cv)
+    _ = search.fit(x_train, y_train)
+
+    return search.best_params_
+
+
+normalize = scikit_utils.scikit_normalize
+dump = scikit_utils.scikit_dump
+predict_from_file = scikit_utils.scikit_predict

src/qibocal/fitting/classifier/data.py

@@ -0,0 +1,27 @@
+import numpy as np
+from sklearn.model_selection import train_test_split
+
+
+def generate_models(data, qubit, test_size=0.25):
+    r"""Extract from data the values stored
+    in the keys `i` and `q` and split them in training and test sets.
+
+    Args:
+        data (DataFrame): Qubit's info.
+        test_size (float | Optional): The proportion of the dataset to include in the train split.
+
+    Returns:
+
+        - x_train: Training inputs.
+        - y_train: Training outputs.
+        - x_test: Test inputs.
+        - y_test: Test outputs.
+    """
+    qubit_data = data.data[qubit]
+    return train_test_split(
+        np.array(qubit_data[["i", "q"]].tolist())[:, :],
+        np.array(qubit_data[["state"]].tolist())[:, 0],
+        test_size=test_size,
+        random_state=0,
+        shuffle=True,
+    )

src/qibocal/fitting/classifier/gaussian_process.py

@@ -0,0 +1,34 @@
+from sklearn.gaussian_process import GaussianProcessClassifier
+from sklearn.gaussian_process.kernels import RBF
+
+from . import scikit_utils
+
+
+def constructor(hyperparams):
+    r"""Return the model class.
+
+    Args:
+        hyperparams: Model hyperparameters.
+    """
+    return GaussianProcessClassifier(1.0 * RBF(1.0)).set_params(**hyperparams)
+
+
+def hyperopt(_x_train, _y_train, _path):
+    r"""Perform an hyperparameter optimization and return the hyperparameters.
+
+    Args:
+        _x_train: Training inputs.
+        _y_train: Training outputs.
+        _path (path): Model save path.
+
+    Returns:
+        Dictionary with model's hyperparameters.
+    """
+    # Build the best model
+    model = GaussianProcessClassifier(1.0 * RBF(1.0))
+    return model.get_params()
+
+
+normalize = scikit_utils.scikit_normalize
+dump = scikit_utils.scikit_dump
+predict_from_file = scikit_utils.scikit_predict

src/qibocal/fitting/classifier/linear_svm.py

@@ -0,0 +1,34 @@
+from sklearn.svm import SVC
+
+from . import scikit_utils
+
+REG_PARAM = 0.025
+
+
+def constructor(hyperpars):
+    r"""Return the model class.
+
+    Args:
+        hyperparams: Model hyperparameters.
+    """
+    return SVC(kernel="linear", C=REG_PARAM).set_params(**hyperpars)
+
+
+def hyperopt(_x_train, _y_train, _path):
+    r"""Perform an hyperparameter optimization and return the hyperparameters.
+
+    Args:
+        _x_train: Training inputs.
+        _y_train: Training outputs.
+        _path (path): Model save path.
+
+    Returns:
+        Dictionary with model's hyperparameters.
+    """
+    model = SVC(kernel="linear", probability=True, C=REG_PARAM)
+    return model.get_params()
+
+
+normalize = scikit_utils.scikit_normalize
+dump = scikit_utils.scikit_dump
+predict_from_file = scikit_utils.scikit_predict

src/qibocal/fitting/classifier/naive_bayes.py

@@ -0,0 +1,32 @@
+from sklearn.naive_bayes import GaussianNB
+
+from . import scikit_utils
+
+
+def constructor(hyperpars):
+    r"""Return the model class.
+
+    Args:
+        hyperparams: Model hyperparameters.
+    """
+    return GaussianNB().set_params(**hyperpars)
+
+
+def hyperopt(_x_train, _y_train, _path):
+    r"""Perform an hyperparameter optimization and return the hyperparameters.
+
+    Args:
+        _x_train: Training inputs.
+        _y_train: Training outputs.
+        _path (path): Model save path.
+
+    Returns:
+        Dictionary with model's hyperparameters.
+    """
+    model = GaussianNB()
+    return model.get_params()
+
+
+normalize = scikit_utils.scikit_normalize
+dump = scikit_utils.scikit_dump
+predict_from_file = scikit_utils.scikit_predict

src/qibocal/fitting/classifier/nn.py

@@ -0,0 +1,43 @@
+import numpy as np
+from sklearn.model_selection import GridSearchCV, RepeatedStratifiedKFold
+from sklearn.neural_network import MLPClassifier
+
+from . import scikit_utils
+
+
+def constructor(hyperpars):
+    r"""Return the model class.
+
+    Args:
+        hyperparams: Model hyperparameters.
+    """
+    return MLPClassifier().set_params(**hyperpars)
+
+
+def hyperopt(x_train, y_train, _path):
+    r"""Perform an hyperparameter optimization and return the hyperparameters.
+
+    Args:
+        x_train: Training inputs.
+        y_train: Training outputs.
+        _path (path): Model save path.
+
+    Returns:
+        Dictionary with model's hyperparameters.
+    """
+    clf = MLPClassifier()
+    cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)
+    space = {}
+    space["hidden_layer_sizes"] = [(16, 16), (16, 32), (16, 64)]
+    space["learning_rate_init"] = np.linspace(1e-4, 1e-2, num=3)
+    space["activation"] = ["logistic", "tanh", "relu"]
+    space["solver"] = ["lbfgs", "sgd", "adam"]
+    search = GridSearchCV(clf, space, scoring="accuracy", n_jobs=-1, cv=cv)
+    _ = search.fit(x_train, y_train)
+
+    return search.best_params_
+
+
+normalize = lambda x: x
+dump = scikit_utils.scikit_dump
+predict_from_file = scikit_utils.scikit_predict

src/qibocal/fitting/classifier/qblox_fit.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+
+import numpy as np
+import numpy.typing as npt
+
+from . import qubit_fit as qfit
+
+
+def constructor(_hyperparams):
+    r"""Return the model class.
+
+    Args:
+        _hyperparams: Model hyperparameters.
+    """
+    return QbloxFit()
+
+
+def hyperopt(_x_train, _y_train, _path):
+    r"""Perform an hyperparameter optimization and return the hyperparameters.
+
+    Args:
+        x_train: Training inputs.
+        y_train: Training outputs.
+        path (path): Model save path.
+
+    Returns:
+        Dictionary with model's hyperparameters.
+    """
+    return {}
+
+
+normalize = lambda x: x
+dump = qfit.dump
+predict_from_file = qfit.predict_from_file
+
+
+@dataclass
+class QbloxFit:
+    r"""This class deploys the Qblox qubit state classifier described
+    in the [documentation](https://qblox-qblox-instruments.readthedocs-hosted.com/en/master/tutorials/conditional_playback.html#Measure-qubit-histogram).
+
+    Args:
+        threshold (float): Classifier's threshold.
+        angle (float): Rotational angle.
+
+    """
+
+    threshold: float = 0.0
+    angle: float = 0.0
+
+    def fit(self, iq_coordinates, states: list):
+        state1 = [complex(*i) for i in iq_coordinates[(states == 1)]]
+        state0 = [complex(*i) for i in iq_coordinates[(states == 0)]]
+        self.angle = np.mod(-np.angle(np.mean(state1) - np.mean(state0)), 2 * np.pi)
+        self.threshold = (
+            np.exp(1j * self.angle) * (np.mean(state1) + np.mean(state0))
+        ).real / 2
+
+    def predict(self, inputs: npt.NDArray):
+        inputs = np.array([complex(*i) for i in inputs])
+        return ((np.exp(1j * self.angle) * inputs).real > self.threshold).astype(int)