PyIAML 1.0.0__py3-none-any.whl

iaml/metrics/f1_score_metric.py

@@ -0,0 +1,71 @@
+"""[METRIC] F1 Score"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import f1_score
+from sklearn.utils.multiclass import type_of_target as get_type_of_target
+from ._classification import resolve_pos_label
+from ..metric import Metric
+
+class F1ScoreMetric(Metric):
+    """[METRIC] F1 Score.
+
+    :param pos_label: Binary positive class. If None, use 1 for 0/1 or -1/1
+        labels, otherwise the last sorted class. Training labels passed to
+        compute as y_train take precedence for automatic class selection.
+        Ignored for multiclass and multilabel targets.
+    """
+
+    name: str = 'F1 Score'
+    _description: str = textwrap.dedent('''\
+        F1 Score is a metric that combines precision and recall to 
+        evaluate a model's performance. It is especially useful for imbalanced datasets, 
+        providing a balance between false positives and false negatives.''')
+    _description_long: str = textwrap.dedent('''\
+        F1 Score measures a model's performance by combining precision 
+        (the accuracy of positive predictions) and recall (the ability to identify all positive cases). 
+        It is calculated as the harmonic mean of precision and recall, making it particularly useful in 
+        healthcare when dealing with imbalanced data.
+        The F1 Score ranges from 0 to 1, where 1 indicates perfect precision and recall. 
+        For example, if a model has a precision of 70% and a recall of 80%, the F1 Score would be 
+        calculated as 2 * (0.70 * 0.80) / (0.70 + 0.80) = 0.74. This metric helps ensure that both false positives 
+        and false negatives are considered, making it valuable for medical decision-making.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2007,
+            'name': 'The truth of the F-measure',
+            'authors': [
+                'Yutaka Sasaki'
+            ],
+            'doi': 'https://www.researchgate.net/publication/268185911_The_truth_of_the_F-measure',
+            'publisher': ' Teach Tutor Mater. Vol. 1, no. 5. pp. 1–5'
+        }
+    ]
+
+    def __init__(self, pos_label: Any = None) -> None:
+        self.pos_label = pos_label
+
+    def __str__(self) -> str:
+        return 'f1_score'
+
+    def suitable(
+        self,
+        X: pd.DataFrame,
+        y: pd.DataFrame,
+        type_of_target: str) -> bool:
+        return type_of_target in ['binary', 'multiclass',  'multilabel-indicator']
+
+    def compute(
+        self,
+        y: pd.DataFrame,
+        y_pred:pd.DataFrame,
+        **kwargs) -> float:
+        y_train = kwargs.get('y_train')
+        match get_type_of_target(y if y_train is None else y_train):
+            case 'multiclass':
+                return f1_score(y, y_pred, average ='weighted')
+            case 'multilabel-indicator':
+                return f1_score(y, y_pred, average ='samples')
+            case _:
+                pos_label = resolve_pos_label(y, self.pos_label, y_train)
+                return f1_score(y, y_pred, pos_label=pos_label, zero_division=0.0)

iaml/metrics/integrated_brier_score.py

@@ -0,0 +1,98 @@
+"""[METRIC] Integrated Brier Score for Survival Models"""
+from typing import Any
+import textwrap
+import pandas as pd
+import numpy as np
+from sksurv.metrics import integrated_brier_score
+from ._survival_times import brier_evaluation_times
+from ..metric import Metric
+from ..dataset import Dataset
+
+
+class IntegratedBrierScoreMetric(Metric):
+    """[METRIC] Integrated Brier Score for Survival Models"""
+
+    name: str = 'Integrated Brier Score'
+    greater_is_better = False
+    _description: str = textwrap.dedent('''\
+        The Integrated Brier Score (IBS) is a measure used to evaluate how well survival 
+        models predict the likelihood of an event happening over time. It looks at the 
+        difference between what the model predicts and what actually happens, including cases 
+        where data is incomplete. A lower IBS score means the model is more accurate.''')
+    _description_long: str = textwrap.dedent('''\
+        The Integrated Brier Score (IBS) is a tool used to check how accurately survival models predict events, 
+        like the time until a patient experiences a certain outcome. It compares the model's predictions with 
+        real-life results over a period of time, taking into account situations where some data may be missing 
+        or incomplete. By looking at these differences, the IBS provides a single score that summarizes the model's 
+        performance. A lower IBS score indicates that the model is doing a better job at making accurate predictions, 
+        which is important for making informed decisions in healthcare and research.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1999,
+            'name': textwrap.dedent("""\
+                Assessment and comparison of prognostic classification schemes for survival data
+                """),
+            'authors': [
+                'E. Graf',
+                'C. Schmoor',
+                'W. Sauerbrei',
+                'M. Schumacher'
+            ],
+            'doi': textwrap.dedent("""\
+                https://doi.org/10.1002/(SICI)1097-0258(19990915/30)18:17/18%3C2529::AID-SIM274%3E3.0.CO;2-5
+                """),
+            'publisher': ' Statistics in Medicine, vol. 18, no. 17-18, pp. 2529–2545'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'integrated_brier_score'
+
+    @property
+    def needed_prediction(self) -> str:
+        return 'predict_survival_function'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'survival'
+
+    def compute(
+        self,
+        y: pd.DataFrame,
+        y_pred: pd.DataFrame,
+        y_train: pd.DataFrame = None,
+        **kwargs) -> float:
+        """Compute the Integrated Brier Score (IBS) with the predicted data.
+
+        Integrate over a 100-point evenly spaced grid over
+        [min(test time), max(test time)), after limiting follow-up to the
+        training horizon. At least two distinct evaluation times are required.
+
+        :param pd.DataFrame y: Ground truth data (duration and event status).
+        :param y_pred: Predicted survival probability functions, one per sample.
+        :param pd.DataFrame y_train: Training data (duration and event status).
+        :param dict, optional \\**kwargs: Additional parameters
+        :return: Computed value
+        """
+        y_train_samples = Dataset.normalize_survival_target(y_train)
+        y_samples = Dataset.fix_y_survival(y, y_train_samples)
+
+        y_train_struct = np.array(
+            y_train_samples,
+            dtype=[('event', 'bool'), ('time', 'float')]
+        )
+        y_struct = np.array(
+            y_samples,
+            dtype=[('event', 'bool'), ('time', 'float')]
+        )
+
+        times = brier_evaluation_times(y_struct['time'])
+        if times.size < 2:
+            raise ValueError(
+                "Integrated Brier score requires at least two distinct evaluation times."
+            )
+
+        # Evaluate survival probabilities on the same grid for every sample.
+        predictions = np.asarray([[fn(t) for t in times] for fn in y_pred])
+
+        # Calculate integrated Brier score using sksurv function
+        return integrated_brier_score(y_train_struct, y_struct, predictions, times)

iaml/metrics/integrated_brier_score_loss.py

@@ -0,0 +1,41 @@
+"""[METRIC] Integrated Brier Score Loss for Survival Models"""
+import textwrap
+import pandas as pd
+from .integrated_brier_score import IntegratedBrierScoreMetric
+
+
+class IntegratedBrierScoreLossMetric(IntegratedBrierScoreMetric):
+    """[METRIC] Integrated Brier Score Loss for Survival Models"""
+
+    name: str = 'Reverse Integrated Brier Score'
+    greater_is_better = True  # This metric returns 1 - IBS.
+    _description: str = textwrap.dedent('''\
+        The Integrated Brier Score (IBS) is a measure used to evaluate how well survival 
+        models predict the likelihood of an event happening over time. Here we compute 1 - IBS''')
+    _description_long: str = textwrap.dedent('''\
+        The Integrated Brier Score (IBS) is a tool used to check how accurately survival models predict events, 
+        like the time until a patient experiences a certain outcome. It compares the model's predictions with 
+        real-life results over a period of time, taking into account situations where some data may be missing 
+        or incomplete. By looking at these differences, the IBS provides a single score that summarizes the model's 
+        performance. A lower IBS score indicates that the model is doing a better job at making accurate predictions, 
+        which is important for making informed decisions in healthcare and research. Here we compute 1 - IBS
+        ''')
+
+    def __str__(self) -> str:
+        return 'integrated_brier_score_loss'
+
+    def compute(
+        self,
+        y: pd.DataFrame,
+        y_pred: pd.DataFrame,
+        y_train: pd.DataFrame = None,
+        **kwargs) -> float:
+        """Compute the Integrated Brier Score Loss (IBS) with the predicted data.
+
+        :param pd.DataFrame y: Ground truth data (duration and event status).
+        :param pd.DataFrame y_pred: Predicted data (risk scores or predicted survival times).
+        :param pd.DataFrame y_train: Training data (duration and event status).
+        :param dict, optional \\**kwargs: Additional parameters
+        :return: Computed value
+        """
+        return 1 - super().compute(y, y_pred, y_train, **kwargs)

iaml/metrics/mean_absolute_error_metric.py

@@ -0,0 +1,46 @@
+"""[METRIC] Mean Absolute Error"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import mean_absolute_error
+from ..metric import Metric
+
+class MeanAbsoluteErrorMetric(Metric):
+    """[METRIC] Mean Absolute Error"""
+
+    name: str = 'Mean Absolute Error'
+    greater_is_better = False
+    _description: str = textwrap.dedent('''\
+        Mean Absolute Error (MAE) evaluates the accuracy of a predictive model by calculating 
+        the average of the absolute differences between predicted and actual values. It is a simple and intuitive metric 
+        that helps understand how far off predictions are from the true outcomes.''')
+    _description_long: str = textwrap.dedent('''\
+        Mean Absolute Error (MAE) evaluates a model's accuracy by calculating the average of the absolute differences 
+        between predicted and actual values. It provides a clear understanding of how far predictions are from true outcomes. 
+        To calculate MAE, you sum the absolute errors (the differences between predicted and actual values) and divide by the 
+        total number of predictions. For example, if the errors are 2, -3, and 1, the MAE would be (|2| + |-3| + |1|) / 3 = 2. 
+        This metric is valuable in healthcare for assessing the accuracy of continuous predictions, like estimating patient 
+        outcomes.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2005,
+            'name': textwrap.dedent("""\
+                Advantages of the mean absolute error (MAE) over the root mean square error 
+                (RMSE) in assessing average model performance"""),
+            'authors': [
+                'Willmott, Cort J',
+                'Matsuura, Kenji'
+            ],
+            'doi': 'https://doi.org/10.3354%2Fcr030079',
+            'publisher': ' Climate Research. 30: 79-82'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'mean_absolute_error'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'continuous'
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        return mean_absolute_error(y, y_pred)

iaml/metrics/mean_squared_error_metric.py

@@ -0,0 +1,46 @@
+"""[METRIC] Mean Squared Error"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import mean_squared_error
+from ..metric import Metric
+
+
+class MeanSquaredErrorMetric(Metric):
+    """[METRIC] Mean Squared Error"""
+
+    name: str = 'Mean Squared Error'
+    greater_is_better = False
+    _description: str = textwrap.dedent('''\
+        Mean Squared Error (MSE) measures the average of the squares of the errors 
+        in predictions. It emphasizes larger errors, making it useful for assessing prediction accuracy.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        Mean Squared Error (MSE) evaluates a model's accuracy by calculating the average of the squared 
+        differences between predicted and actual values. It gives more weight to larger errors, which is important in healthcare.
+        To calculate MSE, you square each error, sum them, and divide by the total number of predictions. 
+        For example, if the errors are 2, -3, and 1, the MSE would be (2² + (-3)² + 1²) / 3 = 4.67. 
+        This metric helps identify how well a model performs, especially when larger errors matter more.
+        ''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2006,
+            'name': 'Mathematical Statistics: Basic Ideas and Selected Topics',
+            'authors': [
+                'Bickel, Peter J'
+            ],
+            'doi': 'https://doi.org/10.1201/9781315369266',
+            'publisher': textwrap.dedent("""\
+                Mathematical Statistics: Basic Ideas and Selected Topics. Vol. I (Second ed.). p. 20
+                """)
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'mean_squared_error'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'continuous'
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        return mean_squared_error(y, y_pred)

iaml/metrics/mean_squared_log_error_metric.py

@@ -0,0 +1,49 @@
+"""[METRIC] Mean Squared Log Error"""
+from typing import Any
+import textwrap
+from sklearn.metrics import mean_squared_log_error
+import pandas as pd
+from ..metric import Metric
+
+
+class MeanSquaredLogErrorMetric(Metric):
+    """[METRIC] Mean Squared Log Error"""
+    name: str = 'Mean Squared Log Error'
+    greater_is_better = False
+    _description: str = textwrap.dedent('''\
+        Mean Squared Log Error (MSLE) measures the average of the squared differences 
+        between the logarithm of predicted and actual values. It is useful for data with wide-ranging values.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        Mean Squared Log Error (MSLE) evaluates a model's accuracy by calculating the 
+        average of the squared differences between the logarithms of predicted and actual values. 
+        This metric is helpful when the target variable varies greatly in scale. 
+        To calculate MSLE, you take the logarithm of both predicted and actual values, find the differences, 
+        square them, and then average these squared differences. This approach reduces the impact of large errors, 
+        making it valuable for assessing model performance in cases where relative differences matter more than 
+        absolute differences.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2021,
+            'name': 'Mean Squared Error, Deconstructed',
+            'authors': [
+                'Timothy O. Hodson',
+                'Thomas M. Over',
+                'Sydney Foks'    
+            ],
+            'doi': 'http://dx.doi.org/10.1029/2021MS002681',
+            'publisher': ' Journal of Advances in Modeling Earth Systems, volume 13'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'mean_squared_log_error'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'continuous' and not (y < 0).any(axis=None)
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float | None:
+        try:
+            return mean_squared_log_error(y, y_pred)
+        except:  # pylint: disable=bare-except
+            return None

iaml/metrics/median_absolute_error_metric.py

@@ -0,0 +1,48 @@
+"""[METRIC] Median Absolute Error"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import median_absolute_error
+from ..metric import Metric
+
+
+class MedianAbsoluteErrorMetric(Metric):
+    """[METRIC] Median Absolute Error"""
+
+    name: str = "Median Absolute Error"
+    greater_is_better = False
+    _description: str = textwrap.dedent('''\
+        Median Absolute Error (MedAE) is a metric used to evaluate the accuracy of a regression model. 
+        It measures the median of the absolute differences between predicted values and actual values, 
+        providing a robust indication of prediction errors.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        Median Absolute Error (MedAE) is a metric that helps assess the accuracy of a regression 
+        model by focusing on the errors in predictions. It calculates the absolute differences between the predicted values 
+        and the actual values, then finds the median of these differences. This approach makes MedAE less sensitive to outliers 
+        compared to other error metrics, as it focuses on the middle value of the errors. A lower MedAE indicates better model 
+        performance, meaning the predictions are closer to the actual values. In summary, MedAE is a useful measure for 
+        understanding the typical prediction error of a regression model.
+        ''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1992,
+            'name': 'Error measures for generalizing about forecasting methods: ' \
+                'Empirical comparisons',
+            'authors': [
+                'Scott Armstrong', 
+                'Fred Collopy'
+            ],
+            'doi': 'https://doi.org/10.1016/j.neucom.2015.12.114',
+            'publisher': 'International Journal of Forecasting, ' \
+                'Volume 8, Issue 1, June 1992, Pages 69-80'
+        }
+    ]
+    def __str__(self) -> str:
+        return 'median_absolute_error'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'continuous'
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        return median_absolute_error(y, y_pred)

iaml/metrics/precision_metric.py

@@ -0,0 +1,63 @@
+"""[METRIC] Precision"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import precision_score
+from sklearn.utils.multiclass import type_of_target as get_type_of_target
+from ._classification import resolve_pos_label
+from ..metric import Metric
+
+
+class PrecisionMetric(Metric):
+    """[METRIC] Precision.
+
+    :param pos_label: Binary positive class. If None, use 1 for 0/1 or -1/1
+        labels, otherwise the last sorted class. Training labels passed to
+        compute as y_train take precedence for automatic class selection.
+        Ignored for multiclass and multilabel targets.
+    """
+
+    name: str = "Precision"
+    _description: str = textwrap.dedent('''\
+        Precision measures the accuracy of positive predictions made by a model. 
+        It indicates the proportion of true positive results among all positive predictions.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        Precision evaluates how many of the predicted positive cases are actually correct. 
+        It is calculated as the number of true positives divided by the sum of true positives and false positives. 
+        For example, if a model predicts 10 positive cases, and 7 of them are correct, the precision would be 70%. 
+        This metric is important in healthcare to ensure that positive predictions are reliable, minimizing false alarms.
+        ''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2007,
+            'name': textwrap.dedent("""\
+                Evaluation: From Precision, Recall and F-Measure to ROC, Informedness, Markedness & Correlation
+                """),
+            'authors': [
+                'David M. W. Powers'
+            ],
+            'doi': 'https://doi.org/10.48550/arXiv.2010.16061',
+            'publisher': 'Journal of Machine Learning Technologies'
+        }
+    ]
+
+    def __init__(self, pos_label: Any = None) -> None:
+        self.pos_label = pos_label
+
+    def __str__(self) -> str:
+        return 'precision'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target in ['binary', 'multiclass',  'multilabel-indicator']
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        y_train = kwargs.get('y_train')
+        match get_type_of_target(y if y_train is None else y_train):
+            case 'multiclass':
+                return precision_score(y, y_pred, average = 'weighted', zero_division=0.0)
+            case 'multilabel-indicator':
+                return precision_score(y, y_pred, average= 'samples', zero_division=0.0)
+            case _:
+                pos_label = resolve_pos_label(y, self.pos_label, y_train)
+                return precision_score(y, y_pred, pos_label=pos_label, zero_division=0.0)

iaml/metrics/r2_score_metric.py

@@ -0,0 +1,45 @@
+"""[METRIC] R2 Score"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import r2_score
+from ..metric import Metric
+
+
+class R2ScoreMetric(Metric):
+    """[METRIC] R2 Score"""
+
+    name: str = "R2 Score"
+    _description: str = textwrap.dedent('''\
+        R² Score, or R-squared, measures how well a model explains the variability of the target variable. 
+        It indicates the proportion of variance in the data that is predictable from the model.''')
+    _description_long: str = textwrap.dedent('''\
+        R² Score evaluates the goodness of fit of a regression model. It ranges from 0 to 1, 
+        where 1 means the model perfectly explains the variability of the target variable, and 0 means it does not 
+        explain any variability. To calculate R², you compare the model's predictions to the mean of the actual values. 
+        For example, an R² of 0.80 means that 80% of the variance in the target variable is explained by the model. 
+        This metric is useful in healthcare to assess how well a model predicts outcomes.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1985,
+            'name': 'Cautionary Note about R2',
+            'authors': [
+                'Robert G. D. Steel',
+                'James H. Torrie'
+            ],
+            'doi': 'https://doi.org/10.2307/2287561',
+            'publisher': textwrap.dedent("""\
+                The American Statistician, Vol. 39, No. 4, Part 1 (Nov., 1985),
+                wpp. 279-285 (7 pages)
+                """)
+        }
+    ]
+
+    def __str__(self) -> Any:
+        return 'r2_score'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'continuous'
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        return r2_score(y, y_pred)

iaml/metrics/recall_metric.py

@@ -0,0 +1,65 @@
+"""[METRIC] Recall"""
+from typing import Any
+import textwrap
+import pandas as pd
+from sklearn.metrics import recall_score
+from sklearn.utils.multiclass import type_of_target as get_type_of_target
+from ._classification import resolve_pos_label
+from ..metric import Metric
+
+
+class RecallMetric(Metric):
+    """[METRIC] Recall.
+
+    :param pos_label: Binary positive class. If None, use 1 for 0/1 or -1/1
+        labels, otherwise the last sorted class. Training labels passed to
+        compute as y_train take precedence for automatic class selection.
+        Ignored for multiclass and multilabel targets.
+    """
+
+    name: str = "Recall"
+    _description: str = textwrap.dedent('''\
+        Recall measures the ability of a model to identify all relevant positive cases. 
+        It indicates the proportion of true positive results among all actual positive cases.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        Recall evaluates how many actual positive cases were correctly predicted by the model. 
+        It is calculated as the number of true positives divided by the total number of actual positives 
+        (true positives + false negatives). For example, if there are 100 actual positive cases and the model 
+        identifies 80, the recall would be 80 / (80 + 20) = 0.80 or 80%. 
+        This metric is crucial in healthcare to ensure that positive cases are detected, reducing missed diagnoses.
+        ''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2007,
+            'name': textwrap.dedent("""\
+                Evaluation: From Precision, Recall and F-Measure to ROC,
+                Informedness, Markedness & Correlation
+                """),
+            'authors': [
+                'David M. W. Powers'
+            ],
+            'doi': 'https://doi.org/10.48550/arXiv.2010.16061',
+            'publisher': 'Journal of Machine Learning Technologies'
+        }
+    ]
+
+    def __init__(self, pos_label: Any = None) -> None:
+        self.pos_label = pos_label
+
+    def __str__(self) -> str:
+        return 'recall'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target in ['binary', 'multiclass',  'multilabel-indicator']
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        y_train = kwargs.get('y_train')
+        match get_type_of_target(y if y_train is None else y_train):
+            case 'multiclass':
+                return recall_score(y, y_pred, average = 'weighted', zero_division=0.0)
+            case 'multilabel-indicator':
+                return recall_score(y, y_pred, average= 'samples', zero_division=0.0)
+            case _:
+                pos_label = resolve_pos_label(y, self.pos_label, y_train)
+                return recall_score(y, y_pred, pos_label=pos_label, zero_division=0.0)

iaml/metrics/roc_auc_metric.py

@@ -0,0 +1,50 @@
+"""[METRIC] ROC AUC"""
+from typing import Any
+import textwrap
+from sklearn.metrics import roc_auc_score
+import pandas as pd
+from ..metric import Metric
+
+
+class RocAucMetric(Metric):
+    """[METRIC] ROC AUC"""
+
+    name: str = "ROC AUC"
+    _description: str = textwrap.dedent('''\
+        The ROC AUC metric (Receiver Operating Characteristic - Area Under the Curve) is a tool used to evaluate 
+        the performance of a classification model. It measures the model's ability to distinguish between two 
+        classes by indicating the proportion of true positives relative to false positives.''')
+    _description_long: str = textwrap.dedent('''\
+        The ROC AUC metric is a method that helps assess the effectiveness of a classification model. 
+        The ROC curve illustrates the model's performance at various decision thresholds, with a curve closer 
+        to the top-left corner indicating better performance. The AUC, or "area under the curve," provides 
+        a score between 0 and 1, where 1 means perfect predictions and 0.5 means the model is no better than 
+        random guessing. In essence, the ROC AUC metric is a clear way to evaluate a 
+        model's ability to correctly distinguish between two categories.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1982,
+            'name': textwrap.dedent("""\
+                The meaning and use of the area under a receiver operating characteristic (ROC) curve.
+                """),
+            'authors': [
+                'Hanley James A.',
+                'McNeil Barbara J.'
+            ],
+            'doi': 'https://doi.org/10.1148%2Fradiology.143.1.7063747',
+            'publisher': 'Radiology. 143 (1): 29-36.'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'ROC AUC'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target == 'binary'
+
+    @property
+    def needed_prediction(self) -> str:
+        return 'predict_proba'
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        return roc_auc_score(y, y_pred[:, 1])