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

lazyqml/Factories/Dispatchers/DispatcherNumba.py

@@ -1,226 +0,0 @@
-from numba import jit, prange
-import numpy as np
-import pandas as pd
-from concurrent.futures import ThreadPoolExecutor
-import time
-from sklearn.metrics import f1_score, accuracy_score, balanced_accuracy_score
-from Factories.Models.fModels import *
-from Factories.Preprocessing.fPreprocessing import *
-from Utils.Utils import *
-import time 
-import math
-
-class Dispatcher:
-    def __init__(self, sequential, threshold=27):
-        self.sequential = sequential
-        self.threshold = threshold
-
-    @staticmethod
-    @jit(nopython=True, parallel=True)
-    def _parallel_predictions(model_predict_func, X_test_values):
-        """
-        Parallel prediction using Numba
-        Note: This is a simplified version - actual implementation would need 
-        to account for model specifics
-        """
-        n_samples = X_test_values.shape[0]
-        predictions = np.zeros(n_samples)
-        
-        for i in prange(n_samples):
-            predictions[i] = model_predict_func(X_test_values[i])
-        
-        return predictions
-
-    @staticmethod
-    @jit(nopython=True)
-    def _calculate_metrics(y_true, y_pred):
-        """
-        Calculate basic metrics using Numba
-        Note: This is a simplified version - actual implementation would need
-        to match sklearn's metric calculations
-        """
-        n_samples = len(y_true)
-        correct = 0
-        for i in range(n_samples):
-            if y_true[i] == y_pred[i]:
-                correct += 1
-        return correct / n_samples
-
-    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
-        total_exeT = 0
-
-        # Convert data to numpy arrays for Numba compatibility
-        X_train_values = X_train.values if isinstance(X_train, pd.DataFrame) else X_train
-        X_test_values = X_test.values if isinstance(X_test, pd.DataFrame) else X_test
-        y_train_values = y_train.values if isinstance(y_train, pd.Series) else y_train
-        y_test_values = y_test.values if isinstance(y_test, pd.Series) else y_test
-
-        for j in range(runs):
-            printer.print(f"\tExecuting {j+1} run of {runs}")
-            start = time.time()
-            
-            # Training can't be easily Numba-optimized due to model complexity
-            model.fit(X=X_train, y=y_train)
-            
-            # Try to use Numba for predictions if possible
-            try:
-                y_pred = self._parallel_predictions(model.predict, X_test_values)
-            except:
-                # Fallback to regular prediction if Numba fails
-                y_pred = model.predict(X=X_test)
-            
-            run_time = time.time() - start
-            total_exeT += run_time
-
-            # Try to use Numba for metric calculation
-            try:
-                accuracy = self._calculate_metrics(y_test_values, y_pred)
-                accuracyR += accuracy
-            except:
-                # Fallback to sklearn metrics if Numba fails
-                accuracyR += accuracy_score(y_test, y_pred, normalize=True)
-            
-            # These metrics are more complex and may not benefit from Numba
-            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
-
-        avg_exeT = total_exeT/runs
-        return avg_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, showTable=True):
-        
-        NAMES, EMBEDDINGS, ANSATZ, ACCURACY = [], [], [], []
-        B_ACCURACY, FEATURES, F1, TIME, CUSTOM = [], [], [], [], []
-        
-        numClasses = len(np.unique(y_train))
-        
-        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.")
-            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 needed
-        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:
-            # Sequential execution
-            for model_args in models_to_run:
-                self._process_single_model(model_args, NAMES, EMBEDDINGS, ANSATZ, ACCURACY,
-                                          B_ACCURACY, FEATURES, F1, TIME, CUSTOM)
-        else:
-            # Parallel execution
-            with ThreadPoolExecutor(max_workers=min(len(models_to_run), psutil.cpu_count())) as executor:
-                futures = []
-                for model_args in models_to_run:
-                    future = executor.submit(self._process_single_model, model_args,
-                                            NAMES, EMBEDDINGS, ANSATZ, ACCURACY,
-                                            B_ACCURACY, FEATURES, F1, TIME, CUSTOM)
-                    futures.append(future)
-                
-                for future in futures:
-                    future.result()
-
-        return self._create_results_dataframe(NAMES, EMBEDDINGS, ANSATZ, FEATURES,
-                                             ACCURACY, B_ACCURACY, F1, CUSTOM, TIME,
-                                             customMetric, showTable)
-
-    def _process_single_model(self, model_args, NAMES, EMBEDDINGS, ANSATZ, ACCURACY,
-                             B_ACCURACY, FEATURES, F1, TIME, CUSTOM):
-        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
-        )
-        
-        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):
-        columns = {
-            "Model": NAMES,
-            "Embedding": EMBEDDINGS,
-            "Ansatz": ANSATZ,
-            "Features": FEATURES,
-            "Accuracy": ACCURACY,
-            "Balanced Accuracy": B_ACCURACY,
-            "F1 Score": F1,
-            "Time taken": TIME,
-        }
-        
-        if customMetric is not None:
-            columns[customMetric.__name__] = CUSTOM
-        
-        scores = pd.DataFrame(columns)
-        
-        if showTable:
-            print(scores.to_markdown())
-        
-        return scores

lazyqml/Factories/Dispatchers/_Dispatcher.py

@@ -1,188 +0,0 @@
-from concurrent.futures import ThreadPoolExecutor
-from Utils.Utils import * 
-import numpy as np
-import pandas as pd
-import math
-from Factories.Models.fModels import *
-from Factories.Preprocessing.fPreprocessing import *
-from sklearn.metrics import f1_score, accuracy_score, balanced_accuracy_score
-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:
-            # 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
-            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/Dispatchers/_DispatcherMultiprocessing.py

@@ -1,201 +0,0 @@
-from multiprocessing import Pool
-from Utils.Utils import * 
-import numpy as np
-import pandas as pd
-import math
-from Factories.Models.fModels import *
-from Factories.Preprocessing.fPreprocessing import *
-from sklearn.metrics import f1_score, accuracy_score, balanced_accuracy_score
-import time
-import psutil
-
-class Dispatcher:
-    def __init__(self, sequential, threshold=27):
-        self.sequential = sequential
-        self.threshold = threshold
-        
-    def _executeModel(self, args):
-        model_params, X_train, y_train, X_test, y_test, predictions, runs, customMetric = args
-        
-        # Recreate the model in this process
-        model = ModelFactory().getModel(**model_params)
-        
-        preds = []
-        accuracyR, b_accuracyR, f1R, customR = 0, 0, 0, 0
-        custom = None
-        exeT = 0
-        
-        for j in range(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
-        return 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, 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.")
-            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 needed
-        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)
-        
-        execution_args = []
-        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}")
-            
-            # Instead of creating the model, we'll just store its parameters
-            model_params = {
-                '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)
-            
-            execution_args.append((
-                model_params, 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:
-            # Sequential execution
-            for args in execution_args:
-                model_params, X_train_p, y_train, X_test_p, y_test, preds, runs, \
-                custom_metric, name, embedding, ansatz, feature = args
-                
-                exe_args = (model_params, X_train_p, y_train, X_test_p, y_test, 
-                           preds, runs, custom_metric)
-                exeT, accuracy, b_accuracy, f1, custom, _ = self._executeModel(exe_args)
-                
-                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 using multiprocessing
-            num_processes = min(len(execution_args), psutil.cpu_count(logical=False))
-            with Pool(processes=num_processes) as pool:
-                results = []
-                for args in execution_args:
-                    model_params, X_train_p, y_train, X_test_p, y_test, preds, runs, \
-                    custom_metric, name, embedding, ansatz, feature = args
-                    
-                    exe_args = (model_params, X_train_p, y_train, X_test_p, y_test, 
-                               preds, runs, custom_metric)
-                    result = pool.apply_async(self._executeModel, (exe_args,))
-                    results.append((result, name, embedding, ansatz, feature))
-                
-                for result, name, embedding, ansatz, feature in results:
-                    exeT, accuracy, b_accuracy, f1, custom, _ = result.get()
-                    self._append_results(NAMES, EMBEDDINGS, ANSATZ, ACCURACY, B_ACCURACY,
-                                        FEATURES, F1, TIME, CUSTOM, name, embedding, ansatz,
-                                        feature, accuracy, b_accuracy, f1, exeT, custom)
-        
-        return self._create_results_dataframe(NAMES, EMBEDDINGS, ANSATZ, FEATURES,
-                                             ACCURACY, B_ACCURACY, F1, CUSTOM, TIME,
-                                             customMetric, showTable)
-
-    # _append_results and _create_results_dataframe methods remain unchanged
-    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/Dispatchers/_QNNBagdispatcher.py

@@ -1,2 +0,0 @@
-def executeQNNBag(combinations):
-    pass

lazyqml/Factories/Dispatchers/_QNNdispatcher.py

@@ -1,2 +0,0 @@
-def executeQNN(combinations):
-    pass