PyIAML 1.0.0__py3-none-any.whl

iaml/metrics/__init__.py

@@ -0,0 +1,21 @@
+"""All metrics to evaluate models"""
+from .accuracy_metric import AccuracyMetric
+from .balanced_accuracy_metric import BalancedAccuracyMetric
+from .brier_score import BrierScoreMetric
+from .classification_error_metric import ClassificationErrorMetric
+from .concordance_index_ipcw import ConcordanceIndexIPCWMetric
+from .concordance_index_metric import ConcordanceIndexMetric
+from .f1_score_metric import F1ScoreMetric
+from .integrated_brier_score_loss import IntegratedBrierScoreLossMetric
+from .integrated_brier_score import IntegratedBrierScoreMetric
+from .mean_absolute_error_metric import MeanAbsoluteErrorMetric
+from .mean_squared_error_metric import MeanSquaredErrorMetric
+from .mean_squared_log_error_metric import MeanSquaredLogErrorMetric
+from .median_absolute_error_metric import MedianAbsoluteErrorMetric
+from .precision_metric import PrecisionMetric
+from .r2_score_metric import R2ScoreMetric
+from .recall_metric import RecallMetric
+from .specificity_metric import SpecificityMetric
+from .specificity_multiclass_metric import SpecificityMulticlassMetric
+from .specificity_multilabel_metric import SpecificityMultilabelMetric
+from .roc_auc_metric import RocAucMetric

iaml/metrics/_classification.py

@@ -0,0 +1,28 @@
+"""Shared positive-class convention for binary classification metrics."""
+from typing import Any
+
+from sklearn.utils.multiclass import unique_labels
+
+
+def resolve_pos_label(y: Any, pos_label: Any = None, y_train: Any = None) -> Any:
+    """Resolve the positive label without depending on row order or predictions.
+
+    Training labels take precedence when available. For 0/1 and -1/1 targets,
+    the positive label is always 1, including all-negative evaluation subsets.
+    Otherwise, use the last of two sorted labels. A single nonstandard label
+    is ambiguous and requires an explicit positive label or both training classes.
+    """
+    if pos_label is not None:
+        return pos_label
+
+    labels = unique_labels(y_train if y_train is not None else y)
+    if 0 < len(labels) <= 2:
+        if all(label in (0, 1) for label in labels) or all(label in (-1, 1) for label in labels):
+            return 1
+        if len(labels) == 2:
+            return labels[-1]
+
+    raise ValueError(
+        "Cannot infer the positive class: set pos_label explicitly or provide "
+        "y_train containing both binary classes."
+    )

iaml/metrics/_survival_times.py

@@ -0,0 +1,22 @@
+"""Evaluation times shared by the survival Brier metrics."""
+import numpy as np
+
+
+def brier_evaluation_times(durations: np.ndarray) -> np.ndarray:
+    """Return up to 100 evenly spaced times in [min(durations), max(durations)).
+
+    A relative grid is independent of the time unit. The endpoint is excluded
+    to keep evaluations inside the follow-up interval, including when the last
+    observation is censored.
+    """
+    durations = np.asarray(durations, dtype=float)
+    if durations.size == 0 or not np.isfinite(durations).all():
+        raise ValueError("Brier scores require non-empty, finite follow-up times.")
+
+    start, stop = durations.min(), durations.max()
+    if start >= stop:
+        raise ValueError("Brier scores require at least two distinct follow-up times.")
+
+    times = np.linspace(start, stop, num=100, endpoint=False)
+    # Very narrow intervals can produce duplicates or round up to the endpoint.
+    return np.unique(times[times < stop])

iaml/metrics/accuracy_metric.py

@@ -0,0 +1,59 @@
+"""[METRIC] Accuracy"""
+from typing import Any
+import textwrap
+from collections import Counter
+from sklearn.metrics import accuracy_score
+import pandas as pd
+from numpy import ndarray
+from ..metric import Metric
+
+class AccuracyMetric(Metric):
+    """[METRIC] Accuracy"""
+    name: str = 'Accuracy'
+    _description: str = textwrap.dedent('''\
+        Accuracy measures how well a model predicts outcomes by calculating the percentage 
+        of correct predictions out of the total predictions. Higher accuracy means better performance.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        Accuracy is a tool to evaluate how well a predictive 
+        model works, especially in healthcare. 
+        It shows the percentage of correct predictions made by the model.
+        To calculate it, you add the number of correct positive and negative predictions, 
+        then divide by the total number of predictions. 
+        For example, if a model is correct 80 times out of 100, its accuracy is 80%.
+        ''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2006,
+            'name': 'Understanding the meaning of accuracy, trueness and precision',
+            'authors': [
+                'Antonio Menditto',
+                'Marina Patriarca',
+                'Bertil Magnusson'    
+            ],
+            'doi': 'https://doi.org/10.1007/s00769-006-0191-z',
+            'publisher': ' Accreditation and Quality Assurance, Volume 12, pages 45--47'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'accuracy'
+
+    def __is_balanced(self, y: ndarray | pd.Series) -> bool:
+        """Get one label (numpy.array or pd.series) and 
+        return true if classes is balanced
+        
+        :return: Whether the dataset is balanced.
+        """
+        class_count = Counter(y)
+        total_samples = y.shape[0]
+        ideal_count = total_samples/len(class_count)
+        threshold = 0.20 * ideal_count
+
+        return not any(abs(count - ideal_count) > threshold for count in class_count.values())
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target in ['binary', 'multiclass'] and not self.__is_balanced(y)
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        return accuracy_score(y, y_pred)

iaml/metrics/balanced_accuracy_metric.py

@@ -0,0 +1,67 @@
+"""[METRIC] Balanced Accuracy"""
+from typing import Any
+import textwrap
+from sklearn.metrics import balanced_accuracy_score
+import pandas as pd
+from ..metric import Metric
+
+
+class BalancedAccuracyMetric(Metric):
+    """[METRIC] Balanced Accuracy"""
+
+    name: str = 'Balanced Accuracy'
+    _description: str = textwrap.dedent('''\
+        Balanced Accuracy Score is a metric that evaluates a model's 
+        performance by considering both positive and negative classes equally. 
+        It calculates the average accuracy for each class, making it useful for imbalanced dataset.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        Balanced Accuracy Score evaluates how well a predictive 
+        model performs, giving equal importance to both positive and negative classes. 
+        This is important in healthcare when data is imbalanced.
+        To calculate it, you find the accuracy for each class and then average those values. 
+        For example, if a model has 70% accuracy for positive cases and 90% for negative cases, 
+        the balanced accuracy is (70% + 90%) / 2 = 80%. This metric ensures that the model is effective 
+        for all classes, making it valuable for medical decision-making.
+        ''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2010,
+            'name': 'The Balanced Accuracy and Its Posterior Distribution',
+            'authors': [
+                'Kay Henning Brodersen',
+                'Cheng Soon Ong',
+                'Klaas Enno Stephan',
+                'Joachim M. Buhmann'
+            ],
+            'doi': 'https://doi.org/10.1109/ICPR.2010.764',
+            'publisher': textwrap.dedent("""\
+                Proceedings of the 20th International Conference on Pattern Recognition, 3121-24.
+                """)
+        },
+        {
+            'year': 2015,
+            'name': textwrap.dedent("""\
+                Fundamentals of Machine Learning for Predictive Data Analytics: Algorithms, 
+                Worked Examples, and Case Studies.
+                """),
+            'authors': [
+                'John D. Kelleher',
+                'Brian Mac Namee',
+                'Aoife D\'Arcy'
+            ],
+            'doi': None,
+            'publisher': textwrap.dedent("""\
+                Fundamentals of Machine Learning for Predictive Data Analytics: Algorithms, Worked Examples, and Case Studies
+                """)
+        }
+    ]
+
+    def __str__(self):
+        return 'balanced_accuracy'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        return type_of_target in ['binary', 'multiclass']
+
+    def compute(self, y: pd.DataFrame, y_pred: pd.DataFrame, **kwargs) -> float:
+        return balanced_accuracy_score(y, y_pred)

iaml/metrics/brier_score.py

@@ -0,0 +1,90 @@
+
+"""[METRIC] Brier Score for Survival Models"""
+from typing import Any
+import textwrap
+import pandas as pd
+import numpy as np
+from sksurv.metrics import brier_score
+from ._survival_times import brier_evaluation_times
+from ..metric import Metric
+from ..dataset import Dataset
+
+class BrierScoreMetric(Metric):
+    """[METRIC] Brier Score for Survival Models"""
+    name: str = 'Brier Score'
+    greater_is_better = False
+    _description: str = textwrap.dedent('''\
+        The Brier Score is a metric used to assess the accuracy of survival models, 
+        which predict the likelihood of an event, such as death or disease, occurring within a specific timeframe. 
+        It compares the model's probability predictions to actual outcomes, with lower scores indicating 
+        better model performance.''')
+    _description_long: str = textwrap.dedent('''\
+        The Brier Score measures how well survival models predict the probability of an event happening, like survival over time. 
+        It calculates the average squared differences between predicted probabilities and actual outcomes 
+        (1 for an event occurring, 0 for it not occurring). The score ranges from 0 to 1, where 0 means perfect 
+        predictions and 1 means completely inaccurate ones. This metric is valuable because it not only evaluates prediction accuracy 
+        but also considers the uncertainty of those predictions. A lower Brier Score indicates a more reliable model, 
+        making it a crucial tool for researchers and practitioners in fields like medicine, where accurate survival 
+        predictions can significantly impact decision-making.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1999,
+            'name': \
+                'Assessment and comparison of prognostic classification schemes for survival data',
+            'authors': [
+                'E. Graf',
+                'C. Schmoor',
+                'W. Sauerbrei',
+                'M. Schumacher'
+            ],
+            'doi': '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 '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 metric given y, y_pred and an optional y_train. 
+
+        Evaluate at the last point of a 100-point evenly spaced grid over
+        [min(test time), max(test time)), after limiting follow-up to the
+        training horizon. The time unit does not determine the grid spacing.
+        
+        :param pd.DataFrame y: Ground truth to compute the metric.
+        :param y_pred: Predicted survival probability functions, one per sample.
+        :param pd.DataFrame, optional y_train: Training ground truth. Default to None.
+        :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')]
+        )
+
+        time = brier_evaluation_times(y_struct['time'])[-1]
+        predictions = [fn(time) for fn in y_pred]
+
+        # Calculate the Brier score at the selected evaluation time.
+        return brier_score(y_train_struct, y_struct, predictions, time)[1][0]

iaml/metrics/classification_error_metric.py

@@ -0,0 +1,66 @@
+"""[METRIC] Classification Error"""
+from typing import Any
+import textwrap
+import pandas as pd
+from .balanced_accuracy_metric import BalancedAccuracyMetric
+from ..metric import Metric
+
+
+class ClassificationErrorMetric(Metric):
+    """[METRIC] Classification Error"""
+    greater_is_better = False
+    name: str = 'Classification Error'
+    _description: str = textwrap.dedent('''\
+        Classification Error measures a model's performance 
+        by calculating the proportion of incorrect predictions. It is defined as 1 
+        minus the Balanced Accuracy Score, making it useful for imbalanced datasets.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        Classification Error evaluates how well a predictive model performs 
+        by measuring the proportion of incorrect predictions. It is calculated as 1 minus the Balanced 
+        Accuracy Score, which gives equal importance to both positive and negative classes. 
+        To calculate it, you first determine the Balanced Accuracy Score, which averages the accuracy 
+        of both classes. Then, you subtract that value from 1. For example, if the Balanced Accuracy Score is 80%, 
+        the Classification Error would be 1 - 0.80 = 0.20, or 20%. This metric helps highlight the model's shortcomings, 
+        making it a valuable tool for assessing performance in medical decision-making.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2010,
+            'name': 'The Balanced Accuracy and Its Posterior Distribution',
+            'authors': [
+                'Kay Henning Brodersen',
+                'Cheng Soon Ong',
+                'Klaas Enno Stephan',
+                'Joachim M. Buhmann'
+            ],
+            'doi': 'https://doi.org/10.1109/ICPR.2010.764',
+            'publisher': textwrap.dedent("""\
+                Proceedings of the 20th International Conference on Pattern Recognition, 3121-24.
+                """)
+        },
+        {
+            'year': 2015,
+            'name': textwrap.dedent("""\
+                Fundamentals of Machine Learning for Predictive Data Analytics: Algorithms, Worked Examples, and Case Studies
+                """),
+            'authors': [
+                'John D. Kelleher',
+                'Brian Mac Namee',
+                'Aoife D\'Arcy'
+            ],
+            'doi': None,
+            'publisher': textwrap.dedent("""\
+                Fundamentals of Machine Learning for Predictive Data Analytics: Algorithms, Worked Examples, and Case Studies
+                """)
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'classification_error'
+
+    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:
+        balanced_accuracy = BalancedAccuracyMetric().compute(y, y_pred)
+        return 1 - balanced_accuracy

iaml/metrics/concordance_index_ipcw.py

@@ -0,0 +1,84 @@
+"""[METRIC] Concordance Index with Inverse Probability of Censoring 
+Weights (IPCW) for Survival Models
+"""
+from typing import Any
+import textwrap
+import pandas as pd
+import numpy as np
+from sksurv.metrics import concordance_index_ipcw
+from ..metric import Metric
+from ..dataset import Dataset
+
+class ConcordanceIndexIPCWMetric(Metric):
+    """[METRIC] Concordance Index with Inverse Probability of Censoring 
+    Weights (IPCW) for Survival Models
+    """
+    name: str = 'C-Index IPC'
+    _description: str = textwrap.dedent('''\
+        The Concordance Index with Inverse Probability of Censoring Weights (IPCW) 
+        evaluates survival models by measuring how well they predict the order of events, 
+        like survival times, while accounting for censored data. A higher index indicates 
+        better predictive accuracy.''')
+    _description_long: str = textwrap.dedent('''\
+        The Concordance Index with Inverse Probability of Censoring Weights (IPCW) 
+        assesses survival models by focusing on the ranking of survival times. It addresses the issue of censored 
+        data—when some outcomes are not fully observed—by applying weights based on the probability of censoring. 
+        The index ranges from 0 to 1, with 0.5 indicating no predictive ability and 1 indicating perfect prediction. 
+        By incorporating IPCW, this metric provides a more accurate evaluation of a model's performance, making it 
+        essential for researchers in fields like medicine and epidemiology.''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 2011,
+            'name': textwrap.dedent("""\
+                On the C-statistics for evaluating overall adequacy of risk prediction 
+                procedures with censored survival data"""),
+            'authors': [
+                'Hajime Uno',
+                'Tianxi Cai',
+                'Michael J. Pencina',
+                'Ralph B. D\'Agostino',
+                'L. J. Wei'
+            ],
+            'doi': 'https://doi.org/10.1002/sim.4154',
+            'publisher': 'Statistics in Medicine, vol. 18, no. 17-18, pp. 2529-2545'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'concordance_index_ipcw'
+
+    @property
+    def needed_prediction(self) -> str:
+        return 'predict'
+
+    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 Concordance Index (C-index) with IPCW using the predicted data.
+        
+        :param pd.DataFrame y: Ground truth to compute the metric.
+        :param pd.DataFrame y_pred: Prediction to compute the metric.
+        :param pd.DataFrame y_train: Training ground truth. Default to None.
+        :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')]
+        )
+
+        # Calculate concordance index using sksurv function
+        return concordance_index_ipcw(y_train_struct, y_struct, y_pred)[0]

iaml/metrics/concordance_index_metric.py

@@ -0,0 +1,67 @@
+"""[METRIC] Concordance Index for Survival Models using sksurv"""
+from typing import Any
+import textwrap
+import numpy as np
+import pandas as pd
+from sksurv.metrics import concordance_index_censored
+from ..dataset import Dataset
+from ..metric import Metric
+
+class ConcordanceIndexMetric(Metric):
+    """[METRIC] Concordance Index for Survival Models using sksurv"""
+    name: str = 'Concordance Index'
+    _description: str = textwrap.dedent('''\
+        The Concordance Index for Survival Models using sksurv measures how well 
+        a survival model predicts the order of events, such as survival times. A higher index 
+        value indicates better predictive accuracy.''')
+    _description_long: str = textwrap.dedent('''\
+        The Concordance Index for Survival Models using sksurv evaluates the performance of 
+        survival models by assessing their ability to correctly rank individuals based on their 
+        survival times. It focuses on the relative timing of events rather than exact predictions. 
+        The index ranges from 0 to 1, where 0.5 indicates no predictive ability (similar to random guessing) 
+        and 1 indicates perfect prediction of event order. This metric is particularly useful in survival 
+        analysis, as it helps researchers and clinicians understand how well their models perform in 
+        predicting outcomes, making it a valuable tool in fields like healthcare and clinical research.
+        ''')
+    refs: list[dict[str, Any]] = [
+        {
+            'year': 1996,
+            'name': textwrap.dedent("""\
+                Multivariable prognostic models: issues in developing models, evaluating assumptions and adequacy, and measuring and reducing errors
+                """),
+            'authors': [
+                'FRANK E.',
+                'HARRELL Jr.',
+                'KERRY L',
+                'LEE',
+                'DANIEL B. MARK'
+            ],
+            'doi': textwrap.dedent("""\
+                https://doi.org/10.1002/(SICI)1097-0258(19960229)15:4%3C361::AID-SIM168%3E3.0.CO;2-4
+                """),
+            'publisher': 'Statistics in Medicine, 15(4), 361-87'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'concordance_index'
+
+    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,
+        **kwargs) -> float:
+        samples = Dataset.normalize_survival_target(y)
+        if not samples:
+            raise ValueError("Survival targets are empty.")
+
+        events = np.asarray([event for event, _ in samples], dtype=bool)
+        times = np.asarray([time for _, time in samples], dtype=float)
+
+        # Calculate concordance index using sksurv function
+        result = concordance_index_censored(events, times, y_pred)
+
+        return result[0]  # The first value in the result is the concordance index

iaml/metrics/cumulative_dynamic_auc.py

@@ -0,0 +1,119 @@
+"""Experimental cumulative AUC implementation for explicit manual investigation.
+
+The current implementation passes survival probabilities where risk scores are
+required, and its time grid and aggregation need validation. Importing this module
+must not activate the metric in AutoML. See docs/component_status.rst.
+"""
+from typing import Any
+import textwrap
+import pandas as pd
+import numpy as np
+from sksurv.metrics import cumulative_dynamic_auc
+from ..metric import Metric
+from ..dataset import Dataset
+
+class CumulativeDynamicAUCMetric(Metric):
+    """[METRIC] Cumulative Dynamic AUC for Survival Models"""
+    name: str = 'Cumulative AUC'
+    _description: str = textwrap.dedent('''\
+        The Cumulative Dynamic AUC (Area Under the Curve) for Survival Models measures the accuracy of a survival model 
+        in predicting the probability of an event over time. A higher AUC indicates better predictive performance.
+        ''')
+    _description_long: str = textwrap.dedent('''\
+        The Cumulative Dynamic AUC for Survival Models evaluates how well a model predicts 
+        the likelihood of an event, such as death or disease, at various time points. Unlike traditional AUC, which 
+        assesses binary classification, the cumulative dynamic AUC accounts for time-dependent predictions 
+        in survival analysis. This metric calculates the area under the curve of the time-dependent receiver 
+        operating characteristic (ROC) curve, providing a comprehensive view of model performance over time. 
+        Values range from 0 to 1, where 0.5 indicates no predictive ability and 1 indicates perfect prediction. 
+        The Cumulative Dynamic AUC is particularly useful for researchers and clinicians in assessing the effectiveness
+        of survival models in real-world scenarios.
+        ''')
+    refs: list[dict[str, Any]]=[
+        {
+            'year': 2007,
+            'name': textwrap.dedent("""\
+                Evaluating prediction rules for t-year survivors with censored regression models
+                """),
+            'authors': [
+                'H. Uno',
+                'T. Cai.',
+                ' L. Tian',
+                'L. J. Wei'
+            ],
+            'doi': 'https://doi.org/10.1198/016214507000000149',
+            'publisher': 'Journal of the American Statistical Association, vol. 102, pp. 527–537'
+        },
+        {
+            'year': 2010,
+            'name': 'Estimation methods for time-dependent AUC models with survival data',
+            'authors': [
+                'H. Hung',
+                'C. T. Chiang'
+            ],
+            'doi': '',
+            'publisher': 'Canadian Journal of Statistics, vol. 38, no. 1, pp. 8–26'
+        },
+        {
+            'year': 2014,
+            'name': textwrap.dedent("""\
+                Summary measure of discrimination in survival models based on cumulative/dynamic time-dependent ROC curves
+                """),
+            'authors': [
+                'J. Lambert',
+                'S. Chevret'
+            ],
+            'doi': '',
+            'publisher': 'Statistical Methods in Medical Research'
+        }
+    ]
+
+    def __str__(self) -> str:
+        return 'cumulative_dynamic_auc'
+
+    @property
+    def needed_prediction(self) -> str:
+        return 'predict_survival_function'
+
+    def suitable(self, X: pd.DataFrame, y: pd.DataFrame, type_of_target: str) -> bool:
+        """Keep this unvalidated implementation outside automatic metric selection."""
+        return False
+
+    def compute(
+        self,
+        y: pd.DataFrame,
+        y_pred: pd.DataFrame,
+        y_train: pd.DataFrame = None,
+        **kwargs) -> float:
+        """Compute the cumulative dynamic AUC using the predicted data.
+
+        :param pd.DataFrame y: Ground truth data (duration and event status).
+        :param pd.DataFrame y_pred: Predicted risk scores or survival probabilities.
+        :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')]
+        )
+
+        # Extract time from y test
+        _, time = zip(*y_samples)
+        times = np.arange(min(time), max(time))
+
+        # Extract risk score for each time point
+        predictions = np.asarray([[fn(t) for t in times] for fn in y_pred])
+
+        # Calculate cumulative dynamic AUC using sksurv function
+        all_points, _ = cumulative_dynamic_auc(y_train_struct, y_struct, predictions, times)
+
+        # Return mean AUC across time points
+        return np.nanmean(all_points)