ddi-fw 0.0.149__py3-none-any.whl → 0.0.151__py3-none-any.whl

ddi_fw/ml/evaluation_helper.py

@@ -1,4 +1,6 @@
+from typing import Any, Dict, List, Literal, Union
 import numpy as np
+from pydantic import BaseModel, Field
 from sklearn import metrics
 from sklearn.metrics import accuracy_score, precision_recall_curve
 from sklearn.metrics import f1_score
@@ -9,43 +11,50 @@ from sklearn.metrics import auc
 from sklearn.metrics import classification_report
 from sklearn.preprocessing import OneHotEncoder
 
-def __format__(d,floating_number_precision = 4):
-    if type(d) is dict:
-        d = {k: __round__(v,floating_number_precision) for k, v in d.items()}
+def __format__(d: Union[Dict[str, Union[List[float], float]], float], floating_number_precision=4) -> Union[Dict[str, Union[List[float], float]], float]:
+    if isinstance(d, dict):
+        d = {k: __round__(v, floating_number_precision) for k, v in d.items()}
     else:
-        d = round(d,floating_number_precision)
+        d = round(d, floating_number_precision)
     return d
 
-def __round__(v,floating_number_precision = 4):
+def __round__(v,floating_number_precision = 4) -> Union[List[float], float]:
     if type(v) is list or type(v) is set:
        return [round(item,floating_number_precision) for item in v]
     else:
         return round(v,floating_number_precision)
 
 
-class Metrics():
-    def __init__(self, label):
-        self.label = label
+class Metrics(BaseModel):
+    label: str
+    accuracy: float = 0.0
+    precision: Any= None
+    recall: Any= None
+    f1_score: Any= None
+    roc_auc: Any= None
+    roc_aupr: Any= None
+    classification_report: Any = None
 
-    def classification_report(self,classification_report):
+
+    def set_classification_report(self,classification_report):
         self.classification_report = classification_report
 
-    def accuracy(self, accuracy):
+    def set_accuracy(self, accuracy):
         self.accuracy = accuracy
 
-    def precision(self, precision):
+    def set_precision(self, precision):
         self.precision = precision
 
-    def recall(self, recall):
+    def set_recall(self, recall):
         self.recall = recall
 
-    def f1_score(self, f1_score):
+    def set_f1_score(self, f1_score):
         self.f1_score = f1_score
 
-    def roc_auc(self, roc_auc):
+    def set_roc_auc(self, roc_auc):
         self.roc_auc = roc_auc
 
-    def roc_aupr(self, roc_aupr):
+    def set_roc_aupr(self, roc_aupr):
         self.roc_aupr = roc_aupr
 
     def format_float(self, floating_number_precision = 4):
@@ -56,6 +65,7 @@ class Metrics():
         self.roc_auc = __format__( self.roc_auc ,floating_number_precision)
         self.roc_aupr = __format__( self.roc_aupr ,floating_number_precision)
 
+ 
 
 # taken from https://github.com/YifanDengWHU/DDIMDL/blob/master/DDIMDL.py#L214
 def roc_aupr_score(y_true, y_score, average="macro"):
@@ -86,7 +96,7 @@ def roc_aupr_score(y_true, y_score, average="macro"):
     return _average_binary_score(_binary_roc_aupr_score, y_true, y_score, average)
 
 
-def evaluate(actual, pred, info='', print=False):
+def evaluate(actual, pred, info='', print_detail=False):
     # Precompute y_true and y_pred
     y_true = np.argmax(actual, axis=1)
     y_pred = np.argmax(pred, axis=1)
@@ -95,7 +105,7 @@ def evaluate(actual, pred, info='', print=False):
     c_report = classification_report(y_true, y_pred, output_dict=True)
     
     # Metrics initialization
-    metrics = Metrics(info)
+    metrics = Metrics(label= info)
     
     n_classes = actual.shape[1]
     
@@ -104,14 +114,15 @@ def evaluate(actual, pred, info='', print=False):
     f_score = {}
     roc_aupr = {}
     roc_auc = {
-        "weighted": 0,
-        "macro": 0,
-        "micro": 0
+        "weighted": 0.0,
+        "macro": 0.0,
+        "micro": 0.0
     }
 
     # Preallocate lists
-    precision_vals = [[] for _ in range(n_classes)]
-    recall_vals = [[] for _ in range(n_classes)]
+    precision_vals: List[np.ndarray] = [np.array([]) for _ in range(n_classes)]
+    recall_vals: List[np.ndarray] = [np.array([]) for _ in range(n_classes)]
+
 
     # Compute metrics for each class
     for i in range(n_classes):
@@ -120,9 +131,9 @@ def evaluate(actual, pred, info='', print=False):
         roc_aupr[i] = auc(recall_vals[i], precision_vals[i])
 
     # Calculate ROC AUC scores
-    roc_auc["weighted"] = roc_auc_score(actual, pred, multi_class='ovr', average='weighted')
-    roc_auc["macro"] = roc_auc_score(actual, pred, multi_class='ovr', average='macro')
-    roc_auc["micro"] = roc_auc_score(actual, pred, multi_class='ovr', average='micro')
+    roc_auc["weighted"] = float(roc_auc_score(actual, pred, multi_class='ovr', average='weighted'))
+    roc_auc["macro"] = float(roc_auc_score(actual, pred, multi_class='ovr', average='macro'))
+    roc_auc["micro"] = float(roc_auc_score(actual, pred, multi_class='ovr', average='micro'))
 
     # Micro-average Precision-Recall curve and ROC-AUPR
     precision["micro_event"], recall["micro_event"], _ = precision_recall_curve(actual.ravel(), pred.ravel())
@@ -136,126 +147,13 @@ def evaluate(actual, pred, info='', print=False):
     acc = accuracy_score(y_true, y_pred)
 
     # Aggregate precision, recall, and f_score
-    for avg_type in ['weighted', 'macro', 'micro']:
+    # for avg_type in ['weighted', 'macro', 'micro']:
+    for avg_type in Literal['weighted', 'macro', 'micro'].__args__:
         precision[avg_type] = precision_score(y_true, y_pred, average=avg_type)
         recall[avg_type] = recall_score(y_true, y_pred, average=avg_type)
         f_score[avg_type] = f1_score(y_true, y_pred, average=avg_type)
 
-    if print:
-        print(
-            f'''Accuracy: {acc}
-            , Precision:{precision['weighted']}
-            , Recall: {recall['weighted']}
-            , F1-score: {f_score['weighted']}
-            ''')
-
-    logs = {'accuracy': acc,
-            'weighted_precision': precision['weighted'],
-            'macro_precision': precision['macro'],
-            'micro_precision': precision['micro'],
-            'weighted_recall_score': recall['weighted'],
-            'macro_recall_score': recall['macro'],
-            'micro_recall_score': recall['micro'],
-            'weighted_f1_score': f_score['weighted'],
-            'macro_f1_score': f_score['macro'],
-            'micro_f1_score': f_score['micro'],
-            # 'weighted_roc_auc_score': weighted_roc_auc_score,
-            # 'macro_roc_auc_score': macro_roc_auc_score,
-            # 'micro_roc_auc_score': micro_roc_auc_score,
-            # 'macro_aupr_score': macro_aupr_score,
-            # 'micro_aupr_score': micro_aupr_score
-            "micro_roc_aupr": roc_aupr['micro'],
-            # "micro_precision_from_precision_recall_curve":precision["micro"],
-            # "micro_recall_from_precision_recall_curve":recall["micro"],
-            "weighted_roc_auc": roc_auc['weighted'],
-            "macro_roc_auc": roc_auc['macro'],
-            "micro_roc_auc": roc_auc['micro']
-            }
-    metrics.accuracy(acc)
-    metrics.precision(precision)
-    metrics.recall(recall)
-    metrics.f1_score(f_score)
-    metrics.roc_auc(roc_auc)
-    metrics.roc_aupr(roc_aupr)
-    metrics.classification_report(c_report)
-    return logs, metrics
-
-
-# actual and pred are one-hot encoded
-def evaluate_ex(actual, pred, info = '' ,print=False):
-    
-    y_pred = np.argmax(pred, axis=1)
-    y_true = np.argmax(actual, axis=1)
-    c_report = classification_report(y_true, y_pred, output_dict = True)
-    
-
-    metrics = Metrics(info)
-
-    precision = dict()
-    recall = dict()
-    f_score = dict()
-    roc_aupr = dict()
-    roc_auc = dict()
-
-    # Compute Precision-Recall and ROC-AUPR for each class
-    for i in range(actual.shape[1]):
-        precision[i], recall[i], _ = precision_recall_curve(
-            actual[:, i].ravel(), pred[:, i].ravel())
-        roc_aupr[i] = auc(recall[i], precision[i])
-        precision[i] = precision[i].tolist()
-        recall[i] = recall[i].tolist()
-        classes = [1 if i == np.argmax(y) else 0 for y in y_true]
-        # roc_auc[i] = roc_auc_score(classes, pred[:,i])
-
-    roc_auc["weighted"] = roc_auc_score(
-        actual, pred, multi_class='ovr', average='weighted')
-    roc_auc["macro"] = roc_auc_score(
-        actual, pred, multi_class='ovr', average='macro')
-    roc_auc["micro"] = roc_auc_score(
-        actual, pred, multi_class='ovr', average='micro')
-
-    # Compute micro-average Precision-Recall curve and ROC-AUPR
-    precision["micro_event"], recall["micro_event"], _ = precision_recall_curve(
-        actual.ravel(), pred.ravel())
-    roc_aupr["micro"] = auc(recall["micro_event"], precision["micro_event"])
-    precision["micro_event"] = precision["micro_event"].tolist()
-    recall["micro_event"] = recall["micro_event"].tolist()
-    # weighted_roc_auc_score = roc_auc_score(actual, pred, multi_class='ovr', average='weighted')
-    # macro_roc_auc_score = roc_auc_score(actual, pred, multi_class='ovr', average='macro')
-    # micro_roc_auc_score = roc_auc_score(actual, pred, multi_class='ovr', average='micro')
-
-    # macro_aupr_score = roc_aupr_score(actual, pred, average='macro')
-    # micro_aupr_score = roc_aupr_score(actual, pred, average='micro')
-
-    acc = accuracy_score(y_true, y_pred)
-
-    precision['weighted'] = precision_score(y_true, y_pred, average='weighted')
-    precision['macro'] = precision_score(y_true, y_pred, average='macro')
-    precision['micro'] = precision_score(y_true, y_pred, average='micro')
-
-    recall['weighted'] = recall_score(y_true, y_pred, average='weighted')
-    recall['macro'] = recall_score(y_true, y_pred, average='macro')
-    recall['micro'] = recall_score(y_true, y_pred, average='micro')
-
-    f_score['weighted'] = f1_score(y_true, y_pred, average='weighted')
-    f_score['macro'] = f1_score(y_true, y_pred, average='macro')
-    f_score['micro'] = f1_score(y_true, y_pred, average='micro')
-
-    # acc = accuracy_score(y_true, y_pred)
-
-    # weighted_precision = precision_score(y_true, y_pred, average='weighted')
-    # macro_precision = precision_score(y_true, y_pred, average='macro')
-    # micro_precision = precision_score(y_true, y_pred, average='micro')
-
-    # weighted_recall_score = recall_score(y_true, y_pred, average='weighted')
-    # macro_recall_score = recall_score(y_true, y_pred, average='macro')
-    # micro_recall_score = recall_score(y_true, y_pred, average='micro')
-
-    # weighted_f1_score = f1_score(y_true, y_pred, average='weighted')
-    # macro_f1_score = f1_score(y_true, y_pred, average='macro')
-    # micro_f1_score = f1_score(y_true, y_pred, average='micro')
-
-    if print:
+    if print_detail:
         print(
             f'''Accuracy: {acc}
             , Precision:{precision['weighted']}
@@ -285,42 +183,13 @@ def evaluate_ex(actual, pred, info = '' ,print=False):
             "macro_roc_auc": roc_auc['macro'],
             "micro_roc_auc": roc_auc['micro']
             }
-    metrics.accuracy(acc)
-    metrics.precision(precision)
-    metrics.recall(recall)
-    metrics.f1_score(f_score)
-    metrics.roc_auc(roc_auc)
-    metrics.roc_aupr(roc_aupr)
-    metrics.classification_report(c_report)
+    metrics.set_accuracy(acc)
+    metrics.set_precision(precision)
+    metrics.set_recall(recall)
+    metrics.set_f1_score(f_score)
+    metrics.set_roc_auc(roc_auc)
+    metrics.set_roc_aupr(roc_aupr)
+    metrics.set_classification_report(c_report)
     return logs, metrics
 
-
-# # Sample integer array
-# integer_array = np.array([0, 1, 2, 1, 0])
-
-# # Reshape the integer array to a column vector
-# integer_array = integer_array.reshape(-1, 1)
-
-# # Create OneHotEncoder object
-# encoder = OneHotEncoder(sparse_output=False)
-
-# # Fit and transform the integer array to one-hot encoded array
-# y_true = encoder.fit_transform(integer_array)
-# # y_true = np.array([[1, 0, 0],
-# #                    [0, 1, 0],
-# #                    [0, 0, 1],
-# #                    [1, 0, 0],
-# #                    [0, 0, 1]],
-# #                    )
-# y_score = np.array([[0.6, 0.2, 0.2],
-#                     [0.2, 0.5, 0.3],
-#                     [0.1, 0.2, 0.7],
-#                     [0.1, 0.8, 0.1],
-#                     [0.1, 0.6, 0.3]])
-
-# y = np.array([-1, -1, 1, 1])
-# pred = np.array([0.1, 0.4, 0.35, 0.8])
-# evaluate(y_true,y_score)
-# fpr, tpr, thresholds = metrics.roc_curve(y, pred)
-# print(metrics.auc(fpr, tpr))
-# print(roc_aupr_score(y,pred))
+  

ddi_fw/ml/ml_helper.py

@@ -1,14 +1,14 @@
-from typing import Dict, List, Tuple
+from typing import Callable, Dict, List, Tuple
 from matplotlib import pyplot as plt
 from ddi_fw.ml.model_wrapper import Result
 from ddi_fw.ml.pytorch_wrapper import PTModelWrapper
 from ddi_fw.ml.tensorflow_wrapper import TFModelWrapper
 from ddi_fw.utils.package_helper import get_import
 import tensorflow as tf
-from tensorflow import keras
-from keras.models import Model, Sequential
-from keras.layers import Dense, Dropout, Input, Activation, BatchNormalization
-from keras.callbacks import EarlyStopping
+from tensorflow.python import keras
+from tensorflow.python.keras import Model, Sequential
+from tensorflow.python.keras.layers import Dense, Dropout, Input, Activation
+from tensorflow.python.keras.callbacks import EarlyStopping
 from sklearn.model_selection import train_test_split, KFold, StratifiedKFold
 import numpy as np
 
@@ -29,26 +29,72 @@ import ddi_fw.utils as utils
 # np.random.seed(2)
 # np.set_printoptions(precision=4)
 
+
 class MultiModalRunner:
     # todo model related parameters to config
-    def __init__(self, library, multi_modal):
+    def __init__(self, library, multi_modal, use_mlflow=True):
         self.library = library
         self.multi_modal = multi_modal
+        self.use_mlflow = use_mlflow
         self.result = Result()
 
+    def _mlflow_(self, func: Callable):
+        if self.use_mlflow:
+            func()
+
     def set_data(self, items, train_idx_arr, val_idx_arr, y_test_label):
         self.items = items
         self.train_idx_arr = train_idx_arr
         self.val_idx_arr = val_idx_arr
         self.y_test_label = y_test_label
 
-    def __create_model(self,library):
+    def __create_model(self, library):
         if library == 'tensorflow':
             return TFModelWrapper
         elif library == 'pytorch':
             return PTModelWrapper
         else:
-            raise ValueError("Unsupported library type. Choose 'tensorflow' or 'pytorch'.")
+            raise ValueError(
+                "Unsupported library type. Choose 'tensorflow' or 'pytorch'.")
+
+    def __predict(self,single_results):
+        item_dict = {t[0]: t for t in self.items}
+        print("multi_modal")
+        print(self.multi_modal)
+        print(item_dict.keys())
+
+        for m in self.multi_modal:
+            name = m.get('name')
+            input_type = m.get('input_type')
+            input = m.get('input')
+            inputs = m.get('inputs')
+            model_type = get_import(m.get("model_type"))
+            kwargs = m.get('params')
+            T = self.__create_model(self.library)
+            single_modal = T(self.date, name, model_type, **kwargs)
+            if input_type == '1D':
+                item = item_dict[input]
+                single_modal.set_data(
+                    self.train_idx_arr, self.val_idx_arr, item[1], item[2], item[3], item[4])
+            elif input_type == '2D':
+                # check keys
+                filtered_dict = {k: item_dict[k]
+                                    for k in inputs if k in item_dict}
+                print(filtered_dict.keys())
+                first_input = next(iter(filtered_dict.values()))
+                train_data_list = [f[1] for f in filtered_dict.values()]
+                test_data_list = [f[3] for f in filtered_dict.values()]
+                train_data = np.stack(train_data_list, axis=1)
+                test_data = np.stack(test_data_list, axis=1)
+                train_label = first_input[2]
+                test_label = first_input[4]
+                single_modal.set_data(
+                    self.train_idx_arr, self.val_idx_arr, train_data, train_label, test_data, test_label)
+            else:
+                raise Exception("check configurations")
+            logs, metrics, prediction = single_modal.fit_and_evaluate()
+            self.result.add_metric(name, metrics)
+            single_results[name] = prediction
 
     def predict(self, combinations: list = [], generate_combinations=False):
         self.prefix = utils.utc_time_as_string()
@@ -62,82 +108,80 @@ class MultiModalRunner:
             combinations = []
             for i in range(2, len(l) + 1):
                 combinations.extend(list(itertools.combinations(l, i)))  # all
-
-        with mlflow.start_run(run_name=self.prefix, description="***") as run:
-            self.level_0_run_id = run.info.run_id
-            item_dict = {t[0]: t for t in self.items}
-            print("multi_modal")
-            print(self.multi_modal)
-            print(item_dict.keys())
-
-            for m in self.multi_modal:
-                name = m.get('name')
-                input_type = m.get('input_type')
-                input = m.get('input')
-                inputs = m.get('inputs')
-                model_type = get_import(m.get("model_type"))
-                kwargs = m.get('params')
-                T = self.__create_model(self.library)
-                single_modal=T(self.date, name, model_type, **kwargs)
-                if input_type == '1D':
-                    item = item_dict[input]
-                    single_modal.set_data(
-                        self.train_idx_arr, self.val_idx_arr, item[1], item[2], item[3], item[4])
-                elif input_type == '2D':
-                    # check keys
-                    filtered_dict = {k: item_dict[k] for k in inputs if k in item_dict}
-                    print(filtered_dict.keys())
-                    first_input = next(iter(filtered_dict.values()))
-                    train_data_list = [f[1] for f in filtered_dict.values()]
-                    test_data_list = [f[3] for f in filtered_dict.values()]
-                    train_data = np.stack(train_data_list, axis=1)
-                    test_data = np.stack(test_data_list, axis=1)
-                    train_label = first_input[2]
-                    test_label = first_input[4]
-                    single_modal.set_data(
-                        self.train_idx_arr, self.val_idx_arr, train_data, train_label, test_data, test_label)
-                else:
-                    raise Exception("check configurations")
-                logs, metrics, prediction = single_modal.fit_and_evaluate()
-                self.result.add_metric(name, metrics)
-                single_results[name] = prediction
-
-
-            # for item in self.items:
-            #     print(item[0])
-            #     T = self.__create_model(self.library)
-            #     # parameters of model should be dictionary 
-            #     single_modal=T(self.date, item[0], self.model_func, self.batch_size, self.epochs)
-            #     single_modal.set_data(
-            #         self.train_idx_arr, self.val_idx_arr, item[1], item[2], item[3], item[4])
-            #     logs, metrics, prediction = single_modal.predict()
-            #     # self.result.add_log(item[0], logs)
-            #     #Check
-            #     self.result.add_metric(item[0], metrics)
-            #     single_results[item[0]] = prediction
-            #     # sum = sum + prediction
-
-            if combinations:
-                self.evaluate_combinations(single_results, combinations)
+        if self.use_mlflow:
+            with mlflow.start_run(run_name=self.prefix, description="***") as run:
+                self.__predict(single_results)
+                # self.level_0_run_id = run.info.run_id
+                # item_dict = {t[0]: t for t in self.items}
+                # print("multi_modal")
+                # print(self.multi_modal)
+                # print(item_dict.keys())
+
+                # for m in self.multi_modal:
+                #     name = m.get('name')
+                #     input_type = m.get('input_type')
+                #     input = m.get('input')
+                #     inputs = m.get('inputs')
+                #     model_type = get_import(m.get("model_type"))
+                #     kwargs = m.get('params')
+                #     T = self.__create_model(self.library)
+                #     single_modal = T(self.date, name, model_type, **kwargs)
+                #     if input_type == '1D':
+                #         item = item_dict[input]
+                #         single_modal.set_data(
+                #             self.train_idx_arr, self.val_idx_arr, item[1], item[2], item[3], item[4])
+                #     elif input_type == '2D':
+                #         # check keys
+                #         filtered_dict = {k: item_dict[k]
+                #                          for k in inputs if k in item_dict}
+                #         print(filtered_dict.keys())
+                #         first_input = next(iter(filtered_dict.values()))
+                #         train_data_list = [f[1] for f in filtered_dict.values()]
+                #         test_data_list = [f[3] for f in filtered_dict.values()]
+                #         train_data = np.stack(train_data_list, axis=1)
+                #         test_data = np.stack(test_data_list, axis=1)
+                #         train_label = first_input[2]
+                #         test_label = first_input[4]
+                #         single_modal.set_data(
+                #             self.train_idx_arr, self.val_idx_arr, train_data, train_label, test_data, test_label)
+                #     else:
+                #         raise Exception("check configurations")
+                #     logs, metrics, prediction = single_modal.fit_and_evaluate()
+                #     self.result.add_metric(name, metrics)
+                #     single_results[name] = prediction
+        else:
+            self.__predict(single_results)
+        if combinations:
+            self.evaluate_combinations(single_results, combinations)
         # TODO: sum'a gerek yok
         return self.result
 
     def evaluate_combinations(self, single_results, combinations):
         for combination in combinations:
             combination_descriptor = '-'.join(combination)
-            with mlflow.start_run(run_name=combination_descriptor, description="***", nested=True) as combination_run:
-                prediction = np.zeros(
-                    (self.y_test_label.shape[0], self.y_test_label.shape[1]))
-                for item in combination:
-                    prediction = prediction + single_results[item]
-                logs, metrics = evaluate(
-                    actual=self.y_test_label, pred=prediction, info=combination_descriptor)
-                mlflow.log_metrics(logs)
-                metrics.format_float()
-                # TODO path bulunamadı hatası aldık
-                print(
-                    f'combination_artifact_uri:{combination_run.info.artifact_uri}')
-                utils.compress_and_save_data(
-                    metrics.__dict__, combination_run.info.artifact_uri, f'{self.date}_metrics.gzip')
-                # self.result.add_log(combination_descriptor,logs)
-                # self.result.add_metric(combination_descriptor,metrics)
+            if self.use_mlflow:
+                with mlflow.start_run(run_name=combination_descriptor, description="***", nested=True) as combination_run:
+                    self.__evaluate_combinations(
+                        single_results, combination, combination_descriptor, combination_run.info.artifact_uri)
+            else:
+                self.__evaluate_combinations(
+                    single_results, combination, combination_descriptor, None)
+
+    def __evaluate_combinations(self, single_results, combination, combination_descriptor, artifact_uri):
+        prediction = np.zeros(
+            (self.y_test_label.shape[0], self.y_test_label.shape[1]))
+        for item in combination:
+            prediction = prediction + single_results[item]
+        logs, metrics = evaluate(
+            actual=self.y_test_label, pred=prediction, info=combination_descriptor)
+        if self.use_mlflow:
+            mlflow.log_metrics(logs)
+        metrics.format_float()
+        # TODO path bulunamadı hatası aldık
+        if artifact_uri:
+            print(
+                f'combination_artifact_uri:{artifact_uri}')
+            utils.compress_and_save_data(
+                metrics.__dict__, artifact_uri, f'{self.date}_metrics.gzip')
+        # self.result.add_log(combination_descriptor,logs)
+        # self.result.add_metric(combination_descriptor,metrics)

ddi_fw/ml/model_wrapper.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Tuple
+from typing import Any, Dict, List, Tuple
 
 from ddi_fw.ml.evaluation_helper import Metrics
 
@@ -31,5 +31,5 @@ class ModelWrapper:
         self.test_label = test_label
 # https://github.com/mlflow/mlflow/blob/master/examples/tensorflow/train.py
 
-    def predict(self) -> Tuple[Dict[str, float], Metrics, List[float]]:
+    def predict(self)-> Any:
         pass