lazyqml 2.0.4__py2.py3-none-any.whl → 3.0.0__py2.py3-none-any.whl

lazyqml/Factories/Dispatchers/_QSVMdispatcher.py

@@ -1,112 +0,0 @@
-from sklearn.metrics import f1_score, accuracy_score, balanced_accuracy_score, roc_auc_score
-from Factories.Models.fModels import *
-from Factories.Preprocessing.fPreprocessing import *
-import time 
-import pandas as pd
-
-def executeQSVM(combinations, nqubits, backend, shots, runs, X_train, y_train, X_test, y_test, customImputerCat,customImputerNum, customMetric,seed, predictions,numClasses):
-    
-    NAMES = []
-    EMBEDDINGS = []
-    ANSATZ = []
-    ACCURACY = []
-    B_ACCURACY = []
-    ROC_AUC = []
-    F1 = []
-    TIME = []
-    PARAMETERS = []
-
-    predictions = {}
-    
-    models = []
-    
-    
-    # Convert input data to pandas DataFrames if they aren't already
-    if not isinstance(X_train, pd.DataFrame):
-        X_train = pd.DataFrame(X_train)
-    if not isinstance(X_test, pd.DataFrame):
-        X_test = pd.DataFrame(X_test)
-    
-    
-    prepFactory = PreprocessingFactory(nqubits)
-    sanitizer = prepFactory.GetSanitizer(customImputerCat, customImputerNum)
-    
-    X_train = sanitizer.fit_transform(X_train)
-    X_test = sanitizer.transform(X_test)
-
-    for i in combinations:
-        print(f"Executing {i} combination of {len(combinations)}")
-        name, embedding, ansatz, feature = i
-        model = ModelFactory(Nqubits=nqubits, Embedding=embedding,Ansatz=ansatz,backend=backend,Shots=shots,seed=seed,N_class=numClasses).GetQSVM()
-        
-        preprocessing = None
-        preprocessing = prepFactory.GetPreprocessing(embedding=embedding,ansatz=ansatz)
-
-        X_train = preprocessing.fit_transform(X=X_train,y=y_train)
-        X_test = preprocessing.transform(X=X_test)
-
-        accuracyR, b_accuracyR, f1R = 0, 0, 0
-        for j in range(runs):
-            print(f"Executing {j+1} run of {runs}")
-            start = time.time()
-            model.fit(X=X_train,y=y_train)
-            exeT = time.time() - start
-            y_pred = model.predict(X=X_test)
-
-            accuracyR += accuracy_score(y_test, y_pred, normalize=True)
-            b_accuracyR += balanced_accuracy_score(y_test, y_pred)
-            f1R += f1_score(y_test, y_pred, average="weighted")
-            # try:
-            #         roc_aucR += roc_auc_score(y_test, y_pred)
-            # except Exception as exception:
-            #         roc_aucR += ""
-        
-        accuracy = accuracyR/runs
-        b_accuracy = b_accuracyR/runs
-        f1 = f1R/runs
-        # roc_auc = roc_aucR/runs
-
-        NAMES.append(name)
-        ANSATZ.append(ansatz)
-        ACCURACY.append(accuracy)
-        B_ACCURACY.append(b_accuracy)
-        # ROC_AUC.append(roc_auc)
-        EMBEDDINGS.append(embedding)
-        F1.append(f1)
-        TIME.append(exeT)
-        PARAMETERS.append("~")
-        
-        if customMetric is not None:
-            customMetricV = customMetric(y_test, y_pred)
-            customMetric.append(customMetricV)
-            scores = pd.DataFrame(
-                {
-                    "Model": NAMES,
-                    "Embedding": EMBEDDINGS,
-                    "Ansatz": ANSATZ,
-                    "Accuracy": ACCURACY,
-                    "Balanced Accuracy": B_ACCURACY,
-                    # "ROC AUC": ROC_AUC,
-                    "F1 Score": F1,
-                    customMetric.__name__: customMetric,
-                    "Trainable Parameters": PARAMETERS,
-                    "Time taken": TIME,
-                }
-            )
-        else:
-            scores = pd.DataFrame(
-                    {
-                        "Model": NAMES,
-                        "Embedding": EMBEDDINGS,
-                        "Ansatz": ANSATZ,
-                        "Accuracy": ACCURACY,
-                        "Balanced Accuracy": B_ACCURACY,
-                        # "ROC AUC": ROC_AUC,
-                        "F1 Score": F1,
-                        "Trainable Parameters": PARAMETERS,
-                        "Time taken": TIME,
-                    }
-                )
-            
-    return scores
-

lazyqml/Factories/Dispatchers/__Dispatcher.py

@@ -1,193 +0,0 @@
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from queue import Queue, Empty
-from threading import Lock
-import psutil
-import numpy as np
-import pandas as pd
-from sklearn.metrics import f1_score, accuracy_score, balanced_accuracy_score
-from Utils.Utils import *
-from Factories.Preprocessing.fPreprocessing import *
-from Factories.Models.fModels import *
-import math
-import time
-
-class Dispatcher:
-    def __init__(self, sequential, threshold=27):
-        self.sequential = sequential
-        self.threshold = threshold
-        
-    def _executeModel(self, model, X_train, y_train, X_test, y_test, predictions, runs, customMetric):
-        preds = []
-        accuracyR, b_accuracyR, f1R, customR = 0, 0, 0, 0
-        custom = None
-        exeT = 0
-        
-        for j in range(runs):
-            printer.print(f"\tExecuting {j+1} run of {runs}")
-            start = time.time()
-            model.fit(X=X_train, y=y_train)
-            exeT += time.time() - start
-            y_pred = model.predict(X=X_test)
-            
-            accuracyR += accuracy_score(y_test, y_pred, normalize=True)
-            b_accuracyR += balanced_accuracy_score(y_test, y_pred)
-            f1R += f1_score(y_test, y_pred, average="weighted")
-            if customMetric is not None:
-                customR += customMetric(y_test, y_pred)
-        
-        if predictions:
-            preds = y_pred
-        accuracy = accuracyR/runs
-        b_accuracy = b_accuracyR/runs
-        f1 = f1R/runs
-        if customMetric is not None:
-            custom = customR/runs
-        
-        exeT = exeT/runs  # Average execution time
-        return exeT, accuracy, b_accuracy, f1, custom, preds
-
-    def _process_model(self, args):
-        model, X_train, y_train, X_test, y_test, predictions, runs, customMetric = args
-        return self._executeModel(model, X_train, y_train, X_test, y_test, predictions, runs, customMetric)
-
-    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, showTable=True):
-        
-        NAMES, EMBEDDINGS, ANSATZ, ACCURACY = [], [], [], []
-        B_ACCURACY, FEATURES, F1, TIME, CUSTOM = [], [], [], [], []
-        
-        numClasses = len(np.unique(y_train))
-        
-        # Adjust qubits if necessary
-        if (numClasses > 2**math.floor(math.log2(nqubits))):
-            printer.print("The number of qubits must exceed the number of classes and be a power of 2 to execute all circuits successfully.")
-            adjustedQubits = adjustQubits(nqubits=nqubits, numClasses=numClasses)
-            printer.print(f"New number of qubits:\t{adjustedQubits}")
-        else:
-            adjustedQubits = nqubits
-        
-        # Convert input data to pandas DataFrames
-        if not isinstance(X_train, pd.DataFrame):
-            X_train = pd.DataFrame(X_train)
-        if not isinstance(X_test, pd.DataFrame):
-            X_test = pd.DataFrame(X_test)
-        
-        # Preprocessing
-        prepFactory = PreprocessingFactory(nqubits)
-        sanitizer = prepFactory.GetSanitizer(customImputerCat, customImputerNum)
-        X_train = sanitizer.fit_transform(X_train)
-        X_test = sanitizer.transform(X_test)
-        
-        combinations = create_combinations(classifiers=classifiers, embeddings=embeddings, 
-                                          features=features, ansatzs=ansatzs)
-        
-        models_to_run = []
-        for combination in combinations:
-            name, embedding, ansatz, feature = combination
-            printer.print("="*100)
-            feature = feature if feature is not None else "~"
-            printer.print(f"Model: {name} Embedding: {embedding} Ansatz:{ansatz} Features: {feature}")
-            
-            model = ModelFactory().getModel(
-                Nqubits=adjustedQubits, model=name, Embedding=embedding, 
-                Ansatz=ansatz, N_class=numClasses, backend=backend,
-                Shots=shots, seed=randomstate, Layers=numLayers,
-                Max_samples=maxSamples, Max_features=feature,
-                LearningRate=learningRate, BatchSize=batch,
-                Epoch=epochs, numPredictors=numPredictors
-            )
-            
-            preprocessing = prepFactory.GetPreprocessing(ansatz=ansatz, embedding=embedding)
-            X_train_processed = preprocessing.fit_transform(X_train, y=y_train)
-            X_test_processed = preprocessing.transform(X_test)
-            
-            models_to_run.append((
-                model, X_train_processed, y_train, X_test_processed, y_test,
-                predictions, runs, customMetric, name, embedding, ansatz, feature
-            ))
-        
-        if self.sequential or backend == "Lightning.GPU" or nqubits >= self.threshold:
-            printer.print("SEQUENTIAL")
-            # Sequential execution
-            for model_args in models_to_run:
-                model, X_train_p, y_train, X_test_p, y_test, preds, runs, custom_metric, \
-                name, embedding, ansatz, feature = model_args
-                
-                exeT, accuracy, b_accuracy, f1, custom, _ = self._executeModel(
-                    model, X_train_p, y_train, X_test_p, y_test, preds, runs, custom_metric
-                )
-                
-                self._append_results(NAMES, EMBEDDINGS, ANSATZ, ACCURACY, B_ACCURACY,
-                                    FEATURES, F1, TIME, CUSTOM, name, embedding, ansatz,
-                                    feature, accuracy, b_accuracy, f1, exeT, custom)
-        else:
-            # Parallel execution
-            printer.print("PARALLEL")
-            with ThreadPoolExecutor(max_workers=min(len(models_to_run), psutil.cpu_count())) as executor:
-                futures = []
-                for model_args in models_to_run:
-                    model, X_train_p, y_train, X_test_p, y_test, preds, runs, custom_metric, \
-                    name, embedding, ansatz, feature = model_args
-                    
-                    future = executor.submit(self._executeModel, model, X_train_p, y_train,
-                                            X_test_p, y_test, preds, runs, custom_metric)
-                    futures.append((future, name, embedding, ansatz, feature))
-                
-                for future, name, embedding, ansatz, feature in futures:
-                    exeT, accuracy, b_accuracy, f1, custom, _ = future.result()
-                    self._append_results(NAMES, EMBEDDINGS, ANSATZ, ACCURACY, B_ACCURACY,
-                                        FEATURES, F1, TIME, CUSTOM, name, embedding, ansatz,
-                                        feature, accuracy, b_accuracy, f1, exeT, custom)
-        
-        # Create and return results DataFrame
-        return self._create_results_dataframe(NAMES, EMBEDDINGS, ANSATZ, FEATURES,
-                                             ACCURACY, B_ACCURACY, F1, CUSTOM, TIME,
-                                             customMetric, showTable)
-
-    def _append_results(self, NAMES, EMBEDDINGS, ANSATZ, ACCURACY, B_ACCURACY,
-                        FEATURES, F1, TIME, CUSTOM, name, embedding, ansatz,
-                        feature, accuracy, b_accuracy, f1, exeT, custom):
-        NAMES.append(name)
-        EMBEDDINGS.append(embedding)
-        ANSATZ.append(ansatz)
-        ACCURACY.append(accuracy)
-        B_ACCURACY.append(b_accuracy)
-        FEATURES.append(feature)
-        F1.append(f1)
-        TIME.append(exeT)
-        CUSTOM.append(custom)
-
-    def _create_results_dataframe(self, NAMES, EMBEDDINGS, ANSATZ, FEATURES,
-                                 ACCURACY, B_ACCURACY, F1, CUSTOM, TIME,
-                                 customMetric, showTable):
-        if customMetric is None:
-            scores = pd.DataFrame({
-                "Model": NAMES,
-                "Embedding": EMBEDDINGS,
-                "Ansatz": ANSATZ,
-                "Features": FEATURES,
-                "Accuracy": ACCURACY,
-                "Balanced Accuracy": B_ACCURACY,
-                "F1 Score": F1,
-                "Time taken": TIME,
-            })
-        else:
-            scores = pd.DataFrame({
-                "Model": NAMES,
-                "Embedding": EMBEDDINGS,
-                "Ansatz": ANSATZ,
-                "Features": FEATURES,
-                "Accuracy": ACCURACY,
-                "Balanced Accuracy": B_ACCURACY,
-                "F1 Score": F1,
-                customMetric.__name__: CUSTOM,
-                "Time taken": TIME,
-            })
-        
-        if showTable:
-            print(scores.to_markdown())
-        
-        return scores

lazyqml/Factories/Preprocessing/_PcaAmp.py

@@ -1,22 +0,0 @@
-from Interfaces.iPreprocessing import Preprocessing
-from sklearn.decomposition import PCA
-from sklearn.exceptions import NotFittedError
-
-class PcaAmp(Preprocessing):
-    def __init__(self, nqubits):
-        self.nqubits = nqubits
-        self.ncomponents = 2**nqubits
-        self.preprocessing = PCA(n_components=self.ncomponents)
-
-    def fit(self, X, y):
-        return self.preprocessing.fit(X, y) if self.ncomponents <= X.shape[1] else X
-
-    def fit_transform(self, X, y):
-        return self.preprocessing.fit_transform(X, y) if self.ncomponents <= X.shape[1] else X
-
-    def transform(self, X):
-        try:
-            fitted_X = self.preprocessing.transform(X)
-        except NotFittedError as e:
-            fitted_X = X
-        return fitted_X

lazyqml/Factories/Preprocessing/_PcaTree.py

@@ -1,22 +0,0 @@
-from Interfaces.iPreprocessing import Preprocessing
-from sklearn.decomposition import PCA
-from sklearn.exceptions import NotFittedError
-
-class PcaTree(Preprocessing):
-    def __init__(self, nqubits):
-        self.nqubits = nqubits
-        self.ncomponents = 2**(self.nqubits.bit_length()-1)
-        self.preprocessing = PCA(n_components=self.ncomponents)
-
-    def fit(self, X, y):
-        return self.preprocessing.fit(X, y) if self.ncomponents <= X.shape[1] else X
-
-    def fit_transform(self, X, y):
-        return self.preprocessing.fit_transform(X, y) if self.ncomponents <= X.shape[1] else X
-
-    def transform(self, X):
-        try:
-            fitted_X = self.preprocessing.transform(X)
-        except NotFittedError as e:
-            fitted_X = X
-        return fitted_X

lazyqml/Factories/Preprocessing/_PcaTreeAmp.py

@@ -1,22 +0,0 @@
-from Interfaces.iPreprocessing import Preprocessing
-from sklearn.decomposition import PCA
-from sklearn.exceptions import NotFittedError
-
-class PcaTreeAmp(Preprocessing):
-    def __init__(self, nqubits):
-        self.nqubits = nqubits
-        self.ncomponents = 2**(2**(self.nqubits.bit_length()-1))
-        self.preprocessing = PCA(n_components=self.ncomponents)
-
-    def fit(self, X, y):
-        return self.preprocessing.fit(X, y) if self.ncomponents <= X.shape[1] else X
-
-    def fit_transform(self, X, y):
-        return self.preprocessing.fit_transform(X, y) if self.ncomponents <= X.shape[1] else X
-
-    def transform(self, X):
-        try:
-            fitted_X = self.preprocessing.transform(X)
-        except NotFittedError as e:
-            fitted_X = X
-        return fitted_X

lazyqml/Lanza copy.sh

@@ -1,32 +0,0 @@
-#!/bin/sh
-# SLRNGPU=A6000
-# SLRGPUS=
-SLRNAME=slave3
-
-# Activar VirtualEnv
-eval "$(/opt/miniconda3/bin/conda shell.bash hook)"
-conda init
-conda config --set auto_activate_base false
-conda activate lazyqml
-cd /home/diegogv/LazyQML/lazyqml
-
-
-# Lanzar ejecucion del script
-# argumentos
-#   Rotationals_family = sys.argv[1].lower() == 'true'
-#   Batch_auto = sys.argv[2].lower() == 'true'
-#   Sequential = sys.argv[3].lower() == 'true'
-#   Node = sys.argv[4].lower()
-
-# EXECUTIONS -> Done
-# true true false -> slave4; slave5; slave3
-# true false false -> slave4; slave5; slave3
-# false true false -> slave4; slave5; slave3
-# false false false -> slave4; slave5; slave3
-
-# true true true -> slave4; slave5; slave3
-# true false true -> slave4; slave5; slave3
-# false true true -> slave4; slave5; slave3
-# false false true -> slave4; slave5;
-
-python lazyqmlP.py true true true slave4

lazyqml/Lanza.sh

@@ -1,21 +0,0 @@
-#!/bin/sh
-# SLRNGPU=A6000
-# SLRGPUS=
-SLRNAME=slave4
-
-# Activar VirtualEnv
-eval "$(/opt/miniconda3/bin/conda shell.bash hook)"
-conda init
-conda config --set auto_activate_base false
-conda activate lazyqml
-cd /home/diegogv/LazyQML/lazyqml
-
-
-# Lanzar ejecucion del script
-# argumentos
-#    Sequential = sys.argv[1].lower() == 'true'
-#    Node = sys.argv[2].lower()
-#    qubits = int(sys.argv[3])
-
-
-python lazyqmlVote.py true slave4 16 16

lazyqml/mem.py

@@ -1,85 +0,0 @@
-import psutil
-import pennylane as qml
-
-def available_memory():
-    """
-    Check the available system memory in bytes using psutil.
-    Returns:
-        available_mem (int): Available RAM in bytes.
-    """
-    mem_info = psutil.virtual_memory()
-    return mem_info.available
-
-def estimate_required_memory(num_qubits, overhead_factor=1.5):
-    """
-    Estimate the required memory for a given number of qubits in a PennyLane circuit.
-    Args:
-        num_qubits (int): Number of qubits in the circuit.
-        overhead_factor (float): Factor to account for memory overhead.
-    Returns:
-        required_memory (int): Estimated required memory in bytes.
-    """
-    # Size of the state vector in bytes: 16 bytes per complex number
-    raw_memory = 16 * (2 ** num_qubits)
-    # Add an overhead to account for non-optimized memory usage
-    required_memory = int(overhead_factor * raw_memory)
-    return required_memory
-
-def check_and_run_circuit(circuit, num_qubits):
-    """
-    Check if the system has sufficient memory to run a PennyLane circuit.
-    Args:
-        circuit (qml.QNode): The PennyLane circuit to be executed.
-        num_qubits (int): Number of qubits in the circuit.
-    Returns:
-        result (any): Result of the circuit execution if memory is sufficient.
-    """
-    # Estimate the required memory
-    required_mem = estimate_required_memory(num_qubits)
-    # Check the available memory
-    available_mem = available_memory()
-
-    # Print memory details
-    print(f"Available Memory: {available_mem / (1024 ** 3):.2f} GB")
-    print(f"Estimated Required Memory: {required_mem / (1024 ** 3):.2f} GB")
-
-    # Check if there is sufficient memory
-    if required_mem > available_mem:
-        print("Insufficient memory to run the circuit. Aborting execution.")
-        return False
-    else:
-        print("Sufficient memory available. Executing circuit...")
-        return True
-
-
-def calculate_quantum_memory(num_qubits, overhead=2):
-    # Each qubit state requires 2 complex numbers (amplitude and phase)
-    # Each complex number uses 2 double-precision floats (16 bytes)
-    bytes_per_qubit_state = 16
-    
-    # Number of possible states is 2^n, where n is the number of qubits
-    num_states = 2 ** num_qubits
-    
-    # Total memory in bytes
-    total_memory_bytes = num_states * bytes_per_qubit_state * overhead
-    
-    # Convert to more readable units
-
-    return total_memory_bytes / (1024**3)
-
-    
-    
-
-def print_memory_requirements(num_qubits):
-    memory = calculate_quantum_memory(num_qubits)
-    print(f"Memory requirements for {num_qubits} qubits:")
-    print(f"Bytes: {memory['bytes']:.2f}")
-    print(f"Kilobytes: {memory['kilobytes']:.2f}")
-    print(f"Megabytes: {memory['megabytes']:.2f}")
-    print(f"Gigabytes: {memory['gigabytes']:.2f}")
-    print(f"Terabytes: {memory['terabytes']:.2f}")
-
-# Example usage
-for qubits in [4, 8, 16, 24, 32, 48]:
-    print_memory_requirements(qubits)
-    print()

lazyqml-2.0.4.dist-info/RECORD

@@ -1,56 +0,0 @@
-lazyqml/.lazyqmlP.py,sha256=WrR6Ojt526lknpYSzvTgJrm3nkIzdtxIBZFrvjttye4,14063
-lazyqml/.lazyqmlVote.py,sha256=PQD9ulY0Pyr_qpJlF6nAals2ymJ6Uh0jdhBZdxFy-ZI,15243
-lazyqml/Lanza copy.sh,sha256=6GVpT67Jbu5NiV0XoN6WTqhKPhlvl1741d6OqjIbcB0,876
-lazyqml/Lanza.sh,sha256=el5dEtYdOlo5-I3iYhX8s0U-wqJQbY_6XzRL16PRgII,435
-lazyqml/__init__.py,sha256=7POJchipxUuWz69eXJ7NQg1p6vRmCmpmJI-6Vj8u6o0,242
-lazyqml/lazyqml.py,sha256=AyndEVMyBfsiaec2hgazCMhJyaFR1RvHYGvnEllNmXI,14161
-lazyqml/mem.py,sha256=ugNznYQPEo3z3bIRywFqhBt6xOPZZePTqyvpLzdZgjQ,2938
-lazyqml/Factories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lazyqml/Factories/Circuits/AmplitudeEmbedding.py,sha256=alkSF082NuQk_FkBfCh3fMPu_d6q7kBIfyhYBztlhYo,646
-lazyqml/Factories/Circuits/HCzRx.py,sha256=vJ5R48GBaEyfKayDF6-g-JfRE5eYBJd6dX_nOPqBEX8,1165
-lazyqml/Factories/Circuits/HardwareEfficient.py,sha256=5fsPtLnw24Vdke_OWy-uBdCGoW7q4Af1qRvuEVhC-jc,1812
-lazyqml/Factories/Circuits/RxEmbedding.py,sha256=m47VHQG4gurVD5gcFJBZH5DlfZ1EtDK4rWyBjnqv2k8,631
-lazyqml/Factories/Circuits/RyEmbedding.py,sha256=EJ3Dc9PoKsE2oPjBiLofp_jk8bLl10IJJoq1vbHeEeM,631
-lazyqml/Factories/Circuits/RzEmbedding.py,sha256=fKL5Mi7JNWsy9qr6PAOS3FFa97m7XUPtUZ2sWHcHYJA,699
-lazyqml/Factories/Circuits/TreeTensor.py,sha256=FRgLe9VariRKUYiNXqiKp1fxdSEV1AvgFNwAFYyAPlU,1298
-lazyqml/Factories/Circuits/TwoLocal.py,sha256=9TVqLlGTmcaVz92vfJCiTHgjJrcvQoT-9wZJL2O3HEw,970
-lazyqml/Factories/Circuits/ZzEmbedding.py,sha256=x3jRAxJcd1uvacvIYyDL39TE-jNVeHhSTUUIREh4XZE,1070
-lazyqml/Factories/Circuits/_Qkernel.py,sha256=HDJJ31zr-dFh2jEy9bcC4BzzE9Jwx0WvG0aq_f5SVkA,619
-lazyqml/Factories/Circuits/_Qnn.py,sha256=ksYeo1w32Getk5sN7MgXbjBGbwQKerkM0ONRJttjfgc,566
-lazyqml/Factories/Circuits/fCircuits.py,sha256=s7t_o5ieKiq8t34qCZhPw_Hww6GmLBwM8Lbo74yrC38,1740
-lazyqml/Factories/Dispatchers/Dispatcher.py,sha256=jPVjEeNOYpMMNEth4wjv64aen2r_1BIHB4NlWbOSLAc,6457
-lazyqml/Factories/Dispatchers/DispatcherCV.py,sha256=Ok4Baz1PSDEkKrJBQ3MxEMxeUTKxtGZiSjGKaw6pruQ,6443
-lazyqml/Factories/Dispatchers/DispatcherNumba.py,sha256=NyibTqImjjuyMU-P4Wn4VFEUrh3FLG8UzbGeh-D4STE,9392
-lazyqml/Factories/Dispatchers/_Dispatcher.py,sha256=0I0AANujQbQVU-PfpAZRpCcdvv42oFWu7qHQQyA0Z7I,8632
-lazyqml/Factories/Dispatchers/_DispatcherMultiprocessing.py,sha256=NLzF4yAdfqf7YF0v0leAZYkrsS8kbmes5Buv8eAopLI,8830
-lazyqml/Factories/Dispatchers/_QNNBagdispatcher.py,sha256=825K5sbEe1mn1gK2zjj07nUXKmXBHOyAca9nfl6hZFo,41
-lazyqml/Factories/Dispatchers/_QNNdispatcher.py,sha256=lqlRxKbx2echnWIu4oyBqi0IEH0_CliC9Fas4ABKx0U,38
-lazyqml/Factories/Dispatchers/_QSVMdispatcher.py,sha256=N9D5OrswlNwqu05QfO2y0LCy8_FoFCYMaSiEq1mpLlc,3923
-lazyqml/Factories/Dispatchers/__Dispatcher.py,sha256=tmTcl_9whBCXFObla8YudsC_qKeSwDIZtDYHacwBZ-o,8794
-lazyqml/Factories/Models/QNNBag.py,sha256=OUaZkEJ97WieFxHYx5lk-AixQGEmI7qp2oFJ_xS_Qms,6608
-lazyqml/Factories/Models/QNNTorch.py,sha256=tln-vO2jRCLVF0IaA63O04768fSIUHs7XLbY4fj0XAM,6577
-lazyqml/Factories/Models/QSVM.py,sha256=X3NUqZTck-rJwg24zqfhqy6xAU5ejPqNYRVgwlO_qws,3249
-lazyqml/Factories/Models/_QNNPennylane.py,sha256=Jpao8PDGA6wrjw651GA8OmmrlAxFciJHj97T2_voamw,3412
-lazyqml/Factories/Models/fModels.py,sha256=0WMazRhDrf9y-DUovZmFDtd-26WXK71MvYq31wav7oE,1374
-lazyqml/Factories/Preprocessing/Pca.py,sha256=TbU2_Y83Eqaha6BhY8wm0YQOzFkcIn6rwVwY8eCvf8g,1000
-lazyqml/Factories/Preprocessing/Sanitizer.py,sha256=iTlu94bPGUJdiyvT7m710wmn55F0F7QuKRzo4lM0sfA,1101
-lazyqml/Factories/Preprocessing/_PcaAmp.py,sha256=HPnH98HF9pQYOV_xUkudmTPPHRpYdXdjYQVDckLtLfc,756
-lazyqml/Factories/Preprocessing/_PcaTree.py,sha256=9QCnj56WyJf3qw4pKwpvX1YjDGuWymt8e1P9drwDqSs,779
-lazyqml/Factories/Preprocessing/_PcaTreeAmp.py,sha256=9yndmz7ntEUKCP2D-F2kSKOool359DiRaqT4Sc_lTas,787
-lazyqml/Factories/Preprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lazyqml/Factories/Preprocessing/fPreprocessing.py,sha256=tD12zgWmeyAgZ0-fIdaLAYiXOClSQ3ml1xh8mh-ekT0,1418
-lazyqml/Global/globalEnums.py,sha256=eALA2Zulcu4Pkw9wGmT8I-k9NlBqyuDiw64Wv9P8whE,728
-lazyqml/Interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lazyqml/Interfaces/iAnsatz.py,sha256=BzXiM9Ed4iav6jq0TrNRxOTOorPQazZA9a07JsdKbW0,164
-lazyqml/Interfaces/iCircuit.py,sha256=L-GbUQmJ2s0uc5AjJj4zIruWP7XSycpG-C8xI4_wnxc,115
-lazyqml/Interfaces/iModel.py,sha256=W_yYoZd7hS8ZKGvNAyl-waJ6f7F0kIM6zrg9WqyPt_I,176
-lazyqml/Interfaces/iPreprocessing.py,sha256=O9f2tCnWTbjkHi4_XKaPWsE2SWKsdI1pj2lCyBWih9o,255
-lazyqml/Utils/Utils.py,sha256=eIX3ah5I51PZWjlZdf2z0kkmaeKdlDKtAKLpgiYQvmU,5328
-lazyqml/Utils/Validator.py,sha256=1KD9NGb5Bw9koyjmPLLdiJ8pbuWIcjIt4eAHAkLZ2_w,4789
-lazyqml-2.0.4.dist-info/AUTHORS.rst,sha256=Y_bDRslOAz5wcAYrTAnjDlmlW-51LfVF0Xwf09TbW3Y,245
-lazyqml-2.0.4.dist-info/LICENSE,sha256=y9EYvUN_l9ZWDuiVcxHE1NWbfy_HR9Z-8G19719ynbQ,1077
-lazyqml-2.0.4.dist-info/METADATA,sha256=d5ouNueIr_e36RZbTIwWDFobF2mn63llKaTZqF84nlE,8728
-lazyqml-2.0.4.dist-info/WHEEL,sha256=B03JAMGq6-VHSCrtDNma_J9UaPCNDvoQGYRXpzGHxgg,109
-lazyqml-2.0.4.dist-info/entry_points.txt,sha256=I0WR08yVIeXjSa8XBSGZ9SsZtM8uMvKwZOdU1qQajao,45
-lazyqml-2.0.4.dist-info/top_level.txt,sha256=x2ffpytT-NeXmC7YaZLSQNMLK0pLfUiRmGOqwNbyjZE,8
-lazyqml-2.0.4.dist-info/RECORD,,