lazyqml 2.0.5__py2.py3-none-any.whl → 3.0.1__py2.py3-none-any.whl

lazyqml/.lazyqmlVote.py

@@ -1,303 +0,0 @@
-import numpy as np
-import pandas as pd
-import sys
-from tabulate import tabulate
-from pydantic import BaseModel, Field, model_validator, field_validator, ValidationError, conset
-from pydantic.config import ConfigDict
-from typing import List, Callable, Optional, Set
-from typing_extensions import Annotated, Set
-from Factories.Preprocessing.fPreprocessing import PreprocessingFactory
-from Global.globalEnums import *
-from Utils.Utils import *
-from Utils.Validator import *
-from Factories.Dispatchers.DispatcherCV import *
-from Factories.Dispatchers.Dispatcher import *
-from sklearn.impute import SimpleImputer
-from ucimlrepo import fetch_ucirepo
-from sklearn.preprocessing import LabelEncoder
-
-class QuantumClassifier(BaseModel):
-    """
-    This module helps in fitting to all the classification algorithms that are available in Scikit-learn
-    Parameters
-    ----------
-    verbose : bool, optional (default=False)
-        Verbose True for showing every training message during the fit.
-    ignoreWarnings : bool, optional (default=True)
-        When set to True, the warning related to algorigms that are not able to run are ignored.
-    customMetric : function, optional (default=None)
-        When function is provided, models are evaluated based on the custom evaluation metric provided.
-    customImputerNum : function, optional (default=None)
-        When function is provided, models are imputed based on the custom numeric imputer provided.
-    customImputerCat : function, optional (default=None)
-        When function is provided, models are imputed based on the custom categorical imputer provided.
-    prediction : bool, optional (default=False)
-        When set to True, the predictions of all the models models are returned as a pandas dataframe.
-    classifiers : list of strings, optional (default=["all"])
-        When function is provided, trains the chosen classifier(s) ["all", "qsvm", "qnn", "qnnbag"].
-    embeddings : list of strings, optional (default=["all"])
-        When function is provided, trains the chosen embeddings(s) ["all", "amplitude_embedding", "ZZ_embedding", "rx_embedding", "rz_embedding", "ry_embedding"].
-    ansatzs : list of strings, optional (default=["all"])
-        When function is provided, trains the chosen ansatzs(s) ["all", "HPzRx", "tree_tensor", "two_local", "hardware_efficient"].
-    randomSate : int, optional (default=1234)
-        This integer is used as a seed for the repeatability of the experiments.
-    nqubits : int, optional (default=8)
-        This integer is used for defining the number of qubits of the quantum circuits that the models will use.
-    numLayers : int, optional (default=5)
-        The number of layers that the Quantum Neural Network (QNN) models will use, is set to 5 by default.
-    numPredictors : int, optional (default=10)
-        The number of different predictoras that the Quantum Neural Networks with Bagging (QNN_Bag) will use, is set to 10 by default.
-    learningRate : int, optional (default=0.01)
-        The parameter that will be used for the optimization process of all the Quantum Neural Networks (QNN) in the gradient descent, is set to 0.01 by default.
-    epochs : int, optional (default=100)
-        The number of complete passes that will be done over the dataset during the fitting of the models.
-    runs : int, optional (default=1)
-        The number of training runs that will be done with the Quantum Neural Network (QNN) models.
-    maxSamples : float, optiona (default=1.0)
-        A floating point number between 0 and 1.0 that indicates the percentage of the dataset that will be used for each Quantum Neural Network with Bagging (QNN_Bag).
-
-    Examples
-    --------
-    >>> from lazyqml.supervised import QuantumClassifier
-    >>> from sklearn.datasets import load_breast_cancer
-    >>> from sklearn.model_selection import train_test_split
-    >>> data = load_breast_cancer()
-    >>> X = data.data
-    >>> y= data.target
-    >>> X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=.5,random_state =123)
-    >>> clf = QuantumClassifier(verbose=0,ignore_warnings=True, customMetric=None)
-    >>> models,predictions = clf.fit(X_train, X_test, y_train, y_test)
-    >>> model_dictionary = clf.provide_models(X_train,X_test,y_train,y_test)
-    >>> models
-    | Model       | Embedding           | Ansatz             |   Accuracy |   Balanced Accuracy |   ROC AUC |   F1 Score |   Time taken |
-    |:------------|:--------------------|:-------------------|-----------:|--------------------:|----------:|-----------:|-------------:|
-    | qsvm        | amplitude_embedding | ~                  |   0.807018 |            0.782339 |  0.782339 |   0.802547 |     43.7487  |
-    | qnn         | amplitude_embedding | hardware_efficient |   0.77193  |            0.743218 |  0.743218 |   0.765533 |      7.92101 |
-    | qnn         | ry_embedding        | hardware_efficient |   0.71345  |            0.689677 |  0.689677 |   0.709295 |      8.00107 |
-    .....................................................................................................................................
-    #####################################################################################################################################
-    .....................................................................................................................................
-    | qnn         | ZZ_embedding        | two_local          |   0.461988 |            0.455954 |  0.455954 |   0.467481 |      2.13294 |
-    """
-    model_config = ConfigDict(strict=True)
-
-    # nqubits: Annotated[int, Field(gt=0)] = 8
-    nqubits: Annotated[Set[int], Field(description="Set of qubits, each must be greater than 0")]
-    randomstate: int = 1234
-    predictions: bool = False
-    ignoreWarnings: bool = True
-    sequential: bool = False
-    numPredictors: Annotated[int, Field(gt=0)] = 10
-    numLayers: Annotated[int, Field(gt=0)] = 5
-    classifiers: Annotated[Set[Model], Field(min_items=1)] = {Model.ALL}
-    ansatzs: Annotated[Set[Ansatzs], Field(min_items=1)] = {Ansatzs.ALL}
-    embeddings: Annotated[Set[Embedding], Field(min_items=1)] = {Embedding.ALL}
-    backend: Backend = Backend.lightningQubit
-    features: Annotated[Set[float], Field(min_items=1)] = {0.3, 0.5, 0.8}
-    learningRate: Annotated[float, Field(gt=0)] = 0.01
-    epochs: Annotated[int, Field(gt=0)] = 100
-    shots: Annotated[int, Field(gt=0)] = 1
-    runs: Annotated[int, Field(gt=0)] = 1
-    batchSize: Annotated[int, Field(gt=0)] = 8
-    threshold: Annotated[int, Field(gt=0)] = 26
-    maxSamples: Annotated[float, Field(gt=0, le=1)] = 1.0
-    verbose: bool = False
-    customMetric: Optional[Callable] = None
-    customImputerNum: Optional[Any] = None
-    customImputerCat: Optional[Any] = None
-    batch: Optional[bool] = True
-    cores: Optional[int] = True
-
-    @field_validator('nqubits', mode='before')
-    def check_nqubits_positive(cls, value):
-        if not isinstance(value, set):
-            raise TypeError('nqubits must be a set of integers')
-
-        if any(v <= 0 for v in value):
-            raise ValueError('Each value in nqubits must be greater than 0')
-
-        return value
-
-    @field_validator('features')
-    def validate_features(cls, v):
-        if not all(0 < x <= 1 for x in v):
-            raise ValueError("All features must be greater than 0 and less than or equal to 1")
-        return v
-
-    @field_validator('customMetric')
-    def validate_custom_metric_field(cls, metric):
-        if metric is None:
-            return None  # Allow None as a valid value
-
-        # Check the function signature
-        sig = inspect.signature(metric)
-        params = list(sig.parameters.values())
-
-        if len(params) < 2 or params[0].name != 'y_true' or params[1].name != 'y_pred':
-            raise ValueError(
-                f"Function {metric.__name__} does not have the required signature. "
-                f"Expected first two arguments to be 'y_true' and 'y_pred'."
-            )
-
-        # Test the function by passing dummy arguments
-        y_true = np.array([0, 1, 1, 0])  # Example ground truth labels
-        y_pred = np.array([0, 1, 0, 0])  # Example predicted labels
-
-        try:
-            result = metric(y_true, y_pred)
-        except Exception as e:
-            raise ValueError(f"Function {metric.__name__} raised an error during execution: {e}")
-
-        # Ensure the result is a scalar (int or float)
-        if not isinstance(result, (int, float)):
-            raise ValueError(
-                f"Function {metric.__name__} returned {result}, which is not a scalar value."
-            )
-
-        return metric
-
-    @field_validator('customImputerCat', 'customImputerNum')
-    def check_preprocessor_methods(cls, preprocessor):
-        # Check if preprocessor is an instance of a class
-        if not isinstance(preprocessor, object):
-            raise ValueError(
-                f"Expected an instance of a class, but got {type(preprocessor).__name__}."
-            )
-
-        # Ensure the object has 'fit' and 'transform' methods
-        if not (hasattr(preprocessor, 'fit') and hasattr(preprocessor, 'transform')):
-            raise ValueError(
-                f"Object {preprocessor.__class__.__name__} does not have required methods 'fit' and 'transform'."
-            )
-
-        # Optionally check if the object has 'fit_transform' method
-        if not hasattr(preprocessor, 'fit_transform'):
-            raise ValueError(
-                f"Object {preprocessor.__class__.__name__} does not have 'fit_transform' method."
-            )
-
-        # Create dummy data for testing the preprocessor methods
-        X_dummy = np.array([[1, 2], [3, 4], [5, 6]])  # Example dummy data
-
-        try:
-            # Ensure the object can fit on data
-            preprocessor.fit(X_dummy)
-        except Exception as e:
-            raise ValueError(f"Object {preprocessor.__class__.__name__} failed to fit: {e}")
-
-        try:
-            # Ensure the object can transform data
-            transformed = preprocessor.transform(X_dummy)
-        except Exception as e:
-            raise ValueError(f"Object {preprocessor.__class__.__name__} failed to transform: {e}")
-
-        # Check the type of the transformed result
-        if not isinstance(transformed, (np.ndarray, list)):
-            raise ValueError(
-                f"Object {preprocessor.__class__.__name__} returned {type(transformed)} from 'transform', expected np.ndarray or list."
-            )
-
-        return preprocessor
-
-    def fit(self, X_train, y_train, X_test, y_test,showTable=True):
-
-
-        printer.set_verbose(verbose=self.verbose)
-        # Validation model to ensure input parameters are DataFrames and sizes match
-        FitParamsValidator(
-            train_x=X_train,
-            train_y=y_train,
-            test_x=X_test,
-            test_y=y_test
-        )
-        printer.print("Validation successful, fitting the model...")
-
-        # Fix seed
-        fixSeed(self.randomstate)
-        d = Dispatcher(sequential=self.sequential,threshold=self.threshold)
-        d.dispatch(nqubits=self.nqubits,randomstate=self.randomstate,predictions=self.predictions,numPredictors=self.numPredictors,numLayers=self.numLayers,classifiers=self.classifiers,ansatzs=self.ansatzs,backend=self.backend,embeddings=self.embeddings,features=self.features,learningRate=self.learningRate,epochs=self.epochs,runs=self.runs,maxSamples=self.maxSamples,verbose=self.verbose,customMetric=self.customMetric,customImputerNum=self.customImputerNum,customImputerCat=self.customImputerCat, X_train=X_train,y_train=y_train, X_test=X_test, y_test=y_test,shots=self.shots,showTable=showTable,batch=self.batchSize,auto=self.batch)
-
-    def repeated_cross_validation(self, X, y, n_splits=10, n_repeats=5, showTable=True):
-        printer.set_verbose(verbose=self.verbose)
-        # Validation model to ensure input parameters are DataFrames and sizes match
-        FitParamsValidatorCV(
-            x=X,
-            y=y
-        )
-        printer.print("Validation successful, fitting the model...")
-
-        # Fix seed
-        fixSeed(self.randomstate)
-        d = DispatcherCV(sequential=self.sequential,threshold=self.threshold,repeats=n_repeats,folds=n_splits)
-        d.dispatch(nqubits=self.nqubits,randomstate=self.randomstate,predictions=self.predictions,numPredictors=self.numPredictors,numLayers=self.numLayers,classifiers=self.classifiers,ansatzs=self.ansatzs,backend=self.backend,embeddings=self.embeddings,features=self.features,learningRate=self.learningRate,epochs=self.epochs,runs=self.runs,maxSamples=self.maxSamples,verbose=self.verbose,customMetric=self.customMetric,customImputerNum=self.customImputerNum,customImputerCat=self.customImputerCat,X_train=X ,X_test=X,y_test=y,y_train=y,shots=self.shots,showTable=showTable,batch=self.batchSize,auto=self.batch,cores=self.cores)
-
-    def leave_one_out(self, X, y, showTable=True):
-        pass
-
-if __name__ == '__main__':
-    Batch_auto = True
-    Sequential = sys.argv[1].lower() == 'true'
-    Node = sys.argv[2].lower()
-    qubits = int(sys.argv[3])
-    cores = int(sys.argv[4])
-
-
-    from sklearn.datasets import load_iris
-
-    dataset="vote"
-
-    # Fetch dataset
-    congressional_voting_records = fetch_ucirepo(id=105)
-
-    # Data (as pandas dataframes)
-    X = congressional_voting_records.data.features
-    y = congressional_voting_records.data.targets
-
-    # Mapping categorical values to numerical values
-    X_numerical = X.replace({'y': 1, 'n': 0, '?': float('NaN')})
-
-    # Option 1: Replace NaNs with a specific value (e.g., -1 or 0)
-    X_numerical_filled = X_numerical.fillna(-1)
-
-    # Or, if you prefer to replace NaN with the column mean, you can use:
-    X_numerical_filled_mean = X_numerical.apply(lambda col: col.fillna(col.mean()))
-
-    print(X_numerical_filled.head())
-    print(X_numerical_filled_mean.head())
-
-    # Handling target variable
-    y_numerical = y.replace({'republican': 1, 'democrat': 0})
-
-    print(y_numerical.head())
-
-    from sklearn.impute import SimpleImputer
-
-    # Imputer for replacing missing values with the mean of each column
-    imputer = SimpleImputer(strategy='mean')
-    X_imputed = pd.DataFrame(imputer.fit_transform(X_numerical), columns=X.columns)
-
-    print(X_imputed.head())
-    X = X_imputed
-    y = y_numerical
-
-    if Node == "slave1":
-        repeats = 4
-        embeddings = {Embedding.AMP}
-    elif Node == "slave2":
-        repeats = 4
-        embeddings = {Embedding.ZZ}
-    elif Node == "slave5":
-        repeats = 2
-        embeddings = {Embedding.ZZ}
-    elif Node == "slave4":
-        repeats = 2
-        embeddings = {Embedding.ZZ}
-
-    print(f"PARAMETERS\nEmbeddings: {embeddings}\tBatch Auto: {Batch_auto}\tSequential: {Sequential}\tNode: {Node}\tDataset: {dataset}\tQubits: {qubits}\t Folds\\Repeats: {(8,repeats)}\tCores: {cores}")
-
-    classifier = QuantumClassifier(nqubits={qubits},classifiers={Model.QSVM},embeddings=embeddings,features={1.0},verbose=True,sequential=Sequential,backend=Backend.lightningQubit,batch=Batch_auto,cores=cores)
-
-    start = time.time()
-    classifier.repeated_cross_validation(X,y,n_repeats=repeats,n_splits=8)
-    print(f"TOTAL TIME: {time.time()-start}s\t PARALLEL: {not Sequential}")
-

lazyqml/Factories/Circuits/_Qkernel.py

@@ -1,16 +0,0 @@
-from lazyqml.Interfaces.iCircuit import Circuit
-from lazyqml.Factories.Circuits.fCircuits import *
-import pennylane as qml
-
-class QkernelCircuit(Circuit):
-    def __init__(self, nqubits, embedding) -> None:
-        self.nqubits = nqubits
-        self.embedding = embedding
-        self.CircuitFactory = CircuitFactory()
-
-    def getCircuit(self):
-        def kernel_circ(a, b):
-            self.CircuitFactory.GetEmbeddingCircuit(self.embedding)(a, wires = range(self.nqubits))
-            qml.adjoint(self.CircuitFactory.GetEmbeddingCircuit(self.embedding))(b, wires = range(self.nqubits)))
-
-        return kernel_circ

lazyqml/Factories/Circuits/_Qnn.py

@@ -1,17 +0,0 @@
-from lazyqml.Interfaces.iCircuit import Circuit
-from Circuits.fCircuits import *
-
-class QnnCircuit(Circuit):
-    def __init__(self, nqubits, nlayers, embedding, ansatz) -> None:
-        self.nqubits = nqubits
-        self.nlayers = nlayers
-        self.embedding = embedding
-        self.ansatz = ansatz
-
-    def getCircuit(self):
-        def qnn_circ(a):
-            CircuitFactory.GetEmbeddingCircuit(self.embedding)(a, wires = range(self.nqubits))
-            CircuitFactory.GetAnsatzCircuit(self.ansatz)(self.nqubits, self.nlayers)
-
-        return qnn_circ
-    

lazyqml/Factories/Dispatchers/DispatcherCV.py

@@ -1,143 +0,0 @@
-from lazyqml.Utils.Utils import *
-import numpy as np
-import pandas as pd
-import math
-from lazyqml.Factories.Models.fModels import *
-from lazyqml.Factories.Preprocessing.fPreprocessing import *
-from sklearn.metrics import f1_score, accuracy_score, balanced_accuracy_score
-import time
-from joblib import Parallel, delayed
-from sklearn.model_selection import RepeatedKFold
-
-class DispatcherCV:
-    def __init__(self, sequential=False, threshold=27, time=True, folds=10, repeats=5):
-        self.sequential = sequential
-        self.threshold = threshold
-        self.timeM = time
-        self.fold = folds
-        self.repeat = repeats
-
-    def execute_model(self, model_factory_params, X_train, y_train, X_test, y_test, predictions,  customMetric):
-        model = ModelFactory().getModel(**model_factory_params)
-        preds = []
-        accuracy, b_accuracy, f1, custom = 0, 0, 0, 0
-        custom = None
-
-        start = time.time()
-
-        model.fit(X=X_train, y=y_train)
-        y_pred = model.predict(X=X_test)
-
-        accuracy += accuracy_score(y_test, y_pred, normalize=True)
-        b_accuracy += balanced_accuracy_score(y_test, y_pred)
-        f1 = f1_score(y_test, y_pred, average="weighted")
-        if customMetric is not None:
-            custom = customMetric(y_test, y_pred)
-
-        exeT = time.time() - start
-
-
-        return model_factory_params['Nqubits'], model_factory_params['model'], model_factory_params['Embedding'], model_factory_params['Ansatz'], model_factory_params['Max_features'], exeT, accuracy, b_accuracy, f1, custom, preds
-
-    def dispatch(self, nqubits, randomstate, predictions, shots,
-                numPredictors, numLayers, classifiers, ansatzs, backend,
-                embeddings, features, learningRate, epochs, runs, batch,
-                maxSamples, verbose, customMetric, customImputerNum,
-                customImputerCat, X_train, y_train, X_test, y_test,
-                auto, cores,showTable=True):
-        t_pre= time.time()
-        combinations = create_combinationsCV(qubits=nqubits,
-                                        classifiers=classifiers,
-                                        embeddings=embeddings,
-                                        features=features,
-                                        ansatzs=ansatzs,
-                                        RepeatID=[i for i in range(self.repeat)],
-                                        FoldID=[i for i in range(self.fold)])
-
-
-
-        X_train = pd.DataFrame(X_train)
-        X_test = pd.DataFrame(X_test)
-
-
-        # Calculate available memory and determine max parallel models
-        available_memory = calculate_free_memory()
-        quantum_memory = calculate_quantum_memory(num_qubits=max(nqubits))
-        max_models_parallel = min(int(available_memory // quantum_memory) if quantum_memory > 0 else float('inf'), psutil.cpu_count(logical=False))
-
-        for combination in combinations:
-            print(combination)
-
-        # Prepare all model executions
-        all_executions = []
-        for combination in combinations:
-            qubits, name, embedding, ansatz, feature, repeat, fold = combination
-            feature = feature if feature is not None else "~"
-
-            numClasses = len(np.unique(y_train))
-            # adjustedQubits = adjustQubits(nqubits=qubits, numClasses=numClasses)
-            adjustedQubits = qubits
-            # print(f"ADJUSTED QUBITS: {adjustedQubits}")
-            prepFactory = PreprocessingFactory(adjustedQubits)
-            sanitizer = prepFactory.GetSanitizer(customImputerCat, customImputerNum)
-
-            X_train = pd.DataFrame(sanitizer.fit_transform(X_train))
-            X_test = pd.DataFrame(sanitizer.transform(X_test))
-
-            model_factory_params = {
-                "Nqubits": adjustedQubits,
-                "model": name,
-                "Embedding": embedding,
-                "Ansatz": ansatz,
-                "N_class": numClasses,
-                "backend": backend,
-                "Shots": shots,
-                "seed": randomstate*repeat,
-                "Layers": numLayers,
-                "Max_samples": maxSamples,
-                "Max_features": feature,
-                "LearningRate": learningRate,
-                "BatchSize": batch,
-                "Epoch": epochs,
-                "numPredictors": numPredictors
-            }
-            # print(f"XTEST SHAPE: {X_test.shape}")
-            # print(f"YTEST SHAPE: {y_test.shape}")
-            # print(f"XTrain SHAPE: {X_train.shape}")
-            # print(f"YTrain SHAPE: {y_train.shape}")
-            preprocessing = prepFactory.GetPreprocessing(ansatz=ansatz, embedding=embedding)
-            X_train_processed = np.array(preprocessing.fit_transform(X_train, y=y_train))
-            X_test_processed = np.array(preprocessing.transform(X_test))
-            y_test = np.array(y_test)
-            y_train = np.array(y_train)
-            # print(f"XTEST PROCESSED SHAPE: {X_test_processed.shape}")
-            # print(f"XTrain PROCESSED SHAPE: {X_train_processed.shape}")
-
-
-            all_executions.append((model_factory_params, X_train_processed, y_train, X_test_processed, y_test, predictions, customMetric))
-        if self.timeM:
-            print(f"PREPROCESSING TIME: {time.time()-t_pre}")
-        # Execute all models in parallel
-        t_exe = time.time()
-        if self.sequential:
-            results = [self.execute_model(*execution_params) for execution_params in all_executions]
-        else:
-            if auto:
-                results = Parallel(n_jobs=cores, prefer='processes',batch_size='auto',verbose=10)(
-                    delayed(self.execute_model)(*execution_params) for execution_params in all_executions
-                )
-            else:
-                results = Parallel(n_jobs=cores, prefer='processes',batch_size=1,verbose=10)(
-                    delayed(self.execute_model)(*execution_params) for execution_params in all_executions
-                )
-        if self.timeM:
-            print(f"EXECUTING TIME: {time.time()-t_exe}")
-        # Process results
-        t_res = time.time()
-        scores = pd.DataFrame(results, columns=["Qubits","Model", "Embedding", "Ansatz", "Features", "Time taken", "Accuracy", "Balanced Accuracy", "F1 Score", "Custom Metric", "Predictions"])
-        if showTable:
-            print(scores.to_markdown())
-
-        if self.timeM:
-            print(f"RESULTS TIME: {time.time()-t_res}")
-        return scores