PyIAML 1.0.0__py3-none-any.whl

iaml/plots/pair_plot.py

@@ -0,0 +1,228 @@
+"""[PLOT] Pair plot for descriptive statistics."""
+from __future__ import annotations
+
+import io
+import textwrap
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from ..data_type import DataType
+from ..dataset import Dataset
+from ..plot import StatisticPlot, capture
+
+
+def _plot_placeholder(message: str) -> None:
+    plt.figure()
+    plt.text(0.5, 0.5, message, ha='center', va='center')
+    plt.axis('off')
+
+
+def _sample_frame(frame: pd.DataFrame, max_points: int) -> pd.DataFrame:
+    if frame.shape[0] <= max_points:
+        return frame
+    indices = np.linspace(0, frame.shape[0] - 1, max_points, dtype=int)
+    return frame.iloc[indices]
+
+
+def _to_numeric_frame(frame: pd.DataFrame) -> pd.DataFrame:
+    return frame.apply(pd.to_numeric, errors='coerce')
+
+
+def _extract_row_values(row: pd.Series) -> pd.DataFrame | None:
+    if not isinstance(row, pd.Series):
+        return None
+    data: dict[str, np.ndarray] = {}
+    min_len: int | None = None
+    for col, value in row.items():
+        if value is None or (isinstance(value, float) and pd.isna(value)):
+            continue
+        arr: np.ndarray | None = None
+        if isinstance(value, dict) and 'values' in value:
+            arr = np.asarray(value['values'])
+        elif isinstance(value, (list, tuple, np.ndarray, pd.Series)):
+            arr = np.asarray(value)
+        if arr is None:
+            continue
+        arr = arr.ravel()
+        if arr.size == 0:
+            continue
+        if min_len is None or arr.size < min_len:
+            min_len = int(arr.size)
+        data[str(col)] = arr
+
+    if not data or min_len is None or min_len < 2:
+        return None
+
+    trimmed = {col: values[:min_len] for col, values in data.items()}
+    return pd.DataFrame(trimmed)
+
+
+def _frame_from_stats(dataframe: pd.DataFrame, key: str) -> pd.DataFrame | None:
+    if dataframe.empty or key not in dataframe.index:
+        return None
+    row = dataframe.loc[key]
+    if isinstance(row, pd.DataFrame):
+        if row.empty:
+            return None
+        row = row.iloc[0]
+    return _extract_row_values(row)
+
+
+def _looks_like_raw_data(dataframe: pd.DataFrame) -> bool:
+    if dataframe.shape[0] < 2 or dataframe.shape[1] < 2:
+        return False
+    stats_keys = {
+        'mean', 'median', 'min', 'max', 'std', 'variance', 'count', 'mode',
+        'null_count', 'missing_rate', 'value_counts', 'range', 'iqr',
+    }
+    if any(str(label) in stats_keys for label in dataframe.index):
+        return False
+    if dataframe.index.dtype == object and dataframe.index.nunique() <= 2:
+        return False
+    numeric = _to_numeric_frame(dataframe)
+    return np.isfinite(numeric.to_numpy()).any()
+
+
+def _select_numeric_frame(
+    dataframe: pd.DataFrame,
+    dataset: Dataset | None,
+    max_features: int,
+    max_points: int,
+) -> pd.DataFrame | None:
+    if dataset is not None:
+        numeric_columns = dataset.get_columns_names_by_type(DataType.NUMERIC)
+        if not numeric_columns:
+            return None
+        columns = numeric_columns[:max_features]
+        frame = dataset.X[columns]
+        frame = _to_numeric_frame(frame)
+        frame = _sample_frame(frame, max_points)
+        return frame
+
+    if _looks_like_raw_data(dataframe):
+        frame = _to_numeric_frame(dataframe)
+        if frame.shape[1] > max_features:
+            frame = frame.iloc[:, :max_features]
+        frame = _sample_frame(frame, max_points)
+        return frame
+
+    return None
+
+
+def _figure_size(n_features: int) -> tuple[float, float]:
+    size = float(min(12.0, max(4.0, 2.2 * n_features)))
+    return size, size
+
+
+class PairPlot(StatisticPlot):
+    """[PLOT] Pair Plot."""
+
+    name: str = "Pair Plot"
+    _description: str = textwrap.dedent("""\
+        Pair plots show pairwise scatter plots between numeric features.
+        """)
+    _description_long: str = textwrap.dedent("""\
+        This plot renders a scatter matrix for a small number of numeric features,
+        highlighting pairwise relationships and marginal distributions.
+        """)
+    refs: list[dict] = []
+
+    title: str = "Pair plot"
+    description: str = textwrap.dedent("""\
+        The pair plot shows pairwise scatter plots for small numeric feature sets.
+        """)
+    group_by_feature: bool = False
+
+    def __str__(self) -> str:
+        return 'pairplot'
+
+    @capture
+    def compute(
+        self,
+        dataframe: pd.DataFrame,
+        dataset: Dataset | None = None,
+        base_name: str | None = None,
+        **kwargs,
+    ) -> 'PairPlot':
+        """Compute pair plot statistics."""
+        self._binary_image = io.BytesIO()
+
+        max_features = int(kwargs.get('max_features', 6))
+        max_points = int(kwargs.get('max_points', 800))
+        max_features = max(2, max_features)
+        max_points = max(50, max_points)
+
+        frame = _frame_from_stats(dataframe, str(self))
+        if frame is None:
+            for candidate in ('pair_plot', 'scatter_matrix', 'scatter'):
+                frame = _frame_from_stats(dataframe, candidate)
+                if frame is not None:
+                    break
+
+        if frame is None:
+            frame = _select_numeric_frame(dataframe, dataset, max_features, max_points)
+
+        if frame is None or frame.empty:
+            _plot_placeholder("Pair plot data not available")
+            plt.savefig(self._binary_image, format='png')
+            return self
+
+        frame = _to_numeric_frame(frame)
+        frame = frame.dropna(how='all')
+        frame = frame.loc[:, frame.notna().any(axis=0)]
+        if frame.shape[1] < 2 or frame.shape[0] < 2:
+            _plot_placeholder("Not enough numeric data for pair plot")
+            plt.savefig(self._binary_image, format='png')
+            return self
+
+        if frame.shape[1] > max_features:
+            frame = frame.iloc[:, :max_features]
+
+        columns = [str(col) for col in frame.columns]
+        n_features = len(columns)
+        fig_w, fig_h = _figure_size(n_features)
+        fig, axes = plt.subplots(n_features, n_features, figsize=(fig_w, fig_h))
+
+        values = frame.to_numpy(dtype=float)
+        for i in range(n_features):
+            for j in range(n_features):
+                ax = axes[i, j]
+                if i == j:
+                    data = values[:, i]
+                    data = data[np.isfinite(data)]
+                    if data.size == 0:
+                        ax.text(0.5, 0.5, "No data", ha='center', va='center')
+                        ax.axis('off')
+                    else:
+                        bins = int(np.sqrt(data.size))
+                        bins = max(5, min(15, bins))
+                        ax.hist(data, bins=bins, color='tab:blue', alpha=0.7)
+                else:
+                    x = values[:, j]
+                    y = values[:, i]
+                    mask = np.isfinite(x) & np.isfinite(y)
+                    if not np.any(mask):
+                        ax.text(0.5, 0.5, "No data", ha='center', va='center')
+                        ax.axis('off')
+                    else:
+                        ax.scatter(x[mask], y[mask], s=10, alpha=0.6, color='tab:blue')
+
+                if i == n_features - 1:
+                    ax.set_xlabel(columns[j], rotation=45, ha='right')
+                else:
+                    ax.set_xticklabels([])
+                if j == 0:
+                    ax.set_ylabel(columns[i])
+                else:
+                    ax.set_yticklabels([])
+
+        title = "Pair plot"
+        if base_name:
+            title = f"Pair plot: {base_name}"
+        fig.suptitle(title)
+        plt.tight_layout(rect=(0, 0, 1, 0.95))
+        plt.savefig(self._binary_image, format='png')
+        return self

iaml/plots/precision_recall_curve_plot.py

@@ -0,0 +1,86 @@
+"""
+[PLOT] Precision-Recall Curve Plot
+"""
+from __future__ import annotations
+
+import textwrap
+import io
+from typing import TYPE_CHECKING
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.metrics import precision_recall_curve, average_precision_score
+
+from ..metric_plot import MetricPlot, capture
+if TYPE_CHECKING:
+    from ..iaml_pipeline import IAMLPipeline
+
+
+class PrecisionRecallCurvePlot(MetricPlot):
+    """[PLOT] Precision-Recall Curve Plot"""
+
+    title: str = "Precision-Recall Curve"
+    description: str = textwrap.dedent("""
+        The Precision-Recall Curve is a valuable visualization tool for evaluating the performance of 
+        a classification model, particularly in healthcare where identifying the correct balance between 
+        precision (positive predictive value) and recall (sensitivity or true positive rate) is critical.
+
+        Precision measures how many of the predicted positive cases (e.g., disease diagnoses) were actually correct, 
+        while recall indicates how well the model identifies all the true positive cases. The Precision-Recall Curve 
+        shows this trade-off across different threshold settings of the model.
+
+        In healthcare, for example, if a model is predicting whether a patient has a disease, the Precision-Recall Curve 
+        will help you understand how the model performs when prioritizing minimizing false positives (increasing precision) 
+        versus maximizing the detection of true positives (increasing recall). This is especially important in imbalanced 
+        datasets where one condition (e.g., healthy patients) dominates over others (e.g., rare diseases).
+
+        Doctors and data scientists rely on this visualization to optimize the model based on specific healthcare priorities, 
+        such as minimizing missed diagnoses or reducing unnecessary treatments, making the Precision-Recall Curve an essential 
+        tool for improving patient outcomes.
+        """)
+
+    @capture
+    def compute( # pylint: disable=arguments-differ
+        self,
+        estimator: IAMLPipeline,
+        X: pd.DataFrame,
+        y: pd.Series,
+        **kwargs) -> MetricPlot:
+        """
+        Compute plot given X, y.
+        """
+        self._binary_image = io.BytesIO()
+
+        pos_label = None
+        if y.dtype == 'int':
+            pos_label = 1
+        elif y.dtype == 'bool':
+            pos_label = True
+        else:
+            pos_label = y.iloc[0] if isinstance(y, pd.Series) else y[0]
+
+        # Predict probabilities for the positive class
+        y_prob = estimator.predict_proba(X)[:, 1]
+
+        # Compute Precision-Recall curve
+        precision, recall, _ = precision_recall_curve(y, y_prob, pos_label=pos_label)
+        average_precision = average_precision_score(y, y_prob, pos_label=pos_label)
+
+        # Create the Precision-Recall plot
+        plt.figure()
+        plt.plot(recall, precision, color='blue',
+            lw=2, label=f'Precision-Recall curve (AP = {average_precision:.2f})')
+        plt.xlabel('Recall')
+        plt.ylabel('Precision')
+        plt.title('Precision-Recall Curve')
+        plt.legend(loc='lower left')
+        plt.grid(True)
+
+        # Save plot to binary image
+        plt.savefig(self._binary_image, format='png')
+        plt.close()
+
+        return self
+
+    @classmethod
+    def suitable(cls, type_of_target: str) -> bool:
+        return type_of_target == 'binary'

iaml/plots/prediction_error_plot.py

@@ -0,0 +1,34 @@
+"""[PLOT] Prediction Error Plot"""
+import textwrap
+
+from yellowbrick.regressor import PredictionError
+
+from ..metric_plot import MetricPlot, yellowbrick_plot
+
+
+@yellowbrick_plot(PredictionError)
+class PredictionErrorPlot(MetricPlot):
+    """[PLOT] Prediction Error Plot"""
+
+    title: str = "Prediction Error"
+    description: str = textwrap.dedent("""
+        The Prediction Error Plot is a diagnostic tool used to visualize the performance of regression models. 
+        It helps assess how well a model's predictions align with the actual values in a continuous prediction 
+        setting, such as predicting medical measurements like blood pressure, heart rate, or glucose levels.
+
+        The plot shows the actual target values on the x-axis and the predicted values on the y-axis. A perfect 
+        model would have all points lying on a 45-degree diagonal line, representing perfect predictions. Deviations 
+        from this line indicate errors in the predictions.
+
+        For instance, if you're building a model to predict a patient's blood pressure based on certain health metrics, 
+        the Prediction Error Plot will show how closely the model's predictions match the actual measurements. If the 
+        points are scattered away from the diagonal, it indicates that the model is making large prediction errors.
+
+        This plot is useful for identifying both systematic errors (consistent overestimation or underestimation) and 
+        random errors (scattering of points) in the model, which is crucial in healthcare settings where accurate 
+        predictions can directly impact patient care.
+        """)
+
+    @classmethod
+    def suitable(cls, type_of_target: str) -> bool:
+        return type_of_target == 'continuous'

iaml/plots/qq_plot.py

@@ -0,0 +1,220 @@
+"""[PLOT] QQ plot for descriptive statistics."""
+from __future__ import annotations
+
+import io
+import textwrap
+from typing import Any
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from scipy import stats
+
+from ..data_type import DataType
+from ..dataset import Dataset
+from ..plot import StatisticPlot, capture
+
+
+def _is_missing(value: Any) -> bool:
+    if value is None:
+        return True
+    if isinstance(value, float) and pd.isna(value):
+        return True
+    return False
+
+
+def _column_label(column: str, base_name: str | None) -> str:
+    column_str = str(column)
+    base_name_str = str(base_name) if base_name is not None else None
+    if base_name_str:
+        if column_str == base_name_str:
+            return 'all'
+        prefix = f"{base_name_str}_"
+        if column_str.startswith(prefix):
+            return column_str[len(prefix):]
+    if column_str.endswith('_all'):
+        return 'all'
+    return column_str
+
+
+def _plot_placeholder(message: str) -> None:
+    plt.figure()
+    plt.text(0.5, 0.5, message, ha='center', va='center')
+    plt.axis('off')
+
+
+def _sample_values(values: np.ndarray, max_points: int = 2000) -> np.ndarray:
+    if values.size <= max_points:
+        return values
+    indices = np.linspace(0, values.size - 1, max_points, dtype=int)
+    return values[indices]
+
+
+def _sanitize_pair(
+    theoretical: np.ndarray,
+    ordered: np.ndarray,
+) -> tuple[np.ndarray, np.ndarray] | None:
+    try:
+        theoretical_arr = np.asarray(theoretical, dtype=float).ravel()
+        ordered_arr = np.asarray(ordered, dtype=float).ravel()
+    except (TypeError, ValueError):
+        return None
+    if theoretical_arr.size == 0 or ordered_arr.size == 0:
+        return None
+    if theoretical_arr.size != ordered_arr.size:
+        return None
+    mask = np.isfinite(theoretical_arr) & np.isfinite(ordered_arr)
+    if not np.any(mask):
+        return None
+    theoretical_arr = theoretical_arr[mask]
+    ordered_arr = ordered_arr[mask]
+    order = np.argsort(theoretical_arr)
+    return theoretical_arr[order], ordered_arr[order]
+
+
+def _qq_from_sample(values: np.ndarray) -> tuple[np.ndarray, np.ndarray] | None:
+    if values.size < 2:
+        return None
+    try:
+        numeric = values.astype(float)
+    except (TypeError, ValueError):
+        return None
+    numeric = numeric[np.isfinite(numeric)]
+    if numeric.size < 2:
+        return None
+    ordered = np.sort(numeric)
+    ordered = _sample_values(ordered)
+    n = ordered.size
+    if n < 2:
+        return None
+    probs = (np.arange(1, n + 1) - 0.5) / n
+    theoretical = stats.norm.ppf(probs)
+    return theoretical, ordered
+
+
+def _extract_qq_data(value: Any) -> tuple[np.ndarray, np.ndarray] | None:
+    if _is_missing(value):
+        return None
+    if isinstance(value, dict):
+        if 'theoretical' in value and 'ordered' in value:
+            return _sanitize_pair(value['theoretical'], value['ordered'])
+        if 'theoretical_quantiles' in value and 'sample_quantiles' in value:
+            return _sanitize_pair(value['theoretical_quantiles'], value['sample_quantiles'])
+        if 'values' in value:
+            return _qq_from_sample(np.asarray(value['values']))
+        if 'sample' in value:
+            return _qq_from_sample(np.asarray(value['sample']))
+    if isinstance(value, (list, tuple, np.ndarray, pd.Series)):
+        if isinstance(value, (list, tuple)) and len(value) == 2:
+            first = np.asarray(value[0])
+            second = np.asarray(value[1])
+            if first.ndim == 1 and second.ndim == 1 and first.size == second.size:
+                return _sanitize_pair(first, second)
+        return _qq_from_sample(np.asarray(value))
+    return None
+
+
+class QQPlot(StatisticPlot):
+    """[PLOT] QQ Plot."""
+
+    name: str = "QQ Plot"
+    _description: str = textwrap.dedent("""\
+        QQ plots compare numeric distributions to a normal reference.
+        """)
+    _description_long: str = textwrap.dedent("""\
+        This plot compares ordered sample values against theoretical quantiles
+        of the normal distribution, highlighting departures from normality.
+        """)
+    refs: list[dict] = []
+
+    title: str = "QQ plot"
+    description: str = textwrap.dedent("""\
+        The QQ plot compares numeric columns to a normal distribution.
+        """)
+    group_by_feature: bool = True
+
+    def __str__(self) -> str:
+        return 'qqplot'
+
+    @capture
+    def compute(
+        self,
+        dataframe: pd.DataFrame,
+        base_name: str | None = None,
+        dataset: Dataset | None = None,
+        **kwargs,
+    ) -> 'QQPlot':
+        """Compute QQ plot statistics."""
+        self._binary_image = io.BytesIO()
+
+        if dataframe.empty:
+            _plot_placeholder("No statistics available")
+            plt.savefig(self._binary_image, format='png')
+            return self
+
+        qq_key = str(self)
+        if qq_key not in dataframe.index:
+            for candidate in ('qq', 'qq_plot'):
+                if candidate in dataframe.index:
+                    qq_key = candidate
+                    break
+            else:
+                _plot_placeholder("QQ plot statistics not available")
+                plt.savefig(self._binary_image, format='png')
+                return self
+
+        if dataset is not None:
+            numeric_columns = set(dataset.get_columns_names_by_type(DataType.NUMERIC))
+            columns_to_show = [col for col in dataframe.columns if col in numeric_columns]
+        else:
+            columns_to_show = list(dataframe.columns)
+
+        qq_row = dataframe.loc[qq_key]
+        entries: list[tuple[str, tuple[np.ndarray, np.ndarray]]] = []
+        for col in columns_to_show:
+            qq_data = _extract_qq_data(qq_row.get(col))
+            if qq_data is not None:
+                entries.append((col, qq_data))
+
+        if not entries:
+            _plot_placeholder("No numeric QQ statistics available")
+            plt.savefig(self._binary_image, format='png')
+            return self
+
+        n_plots = len(entries)
+        n_cols = 1 if n_plots == 1 else 2
+        n_rows = int(np.ceil(n_plots / n_cols))
+        fig, axes = plt.subplots(n_rows, n_cols, figsize=(6 * n_cols, 3.5 * n_rows))
+        axes_list = np.atleast_1d(axes).ravel()
+
+        for ax, (col, (theoretical, ordered)) in zip(axes_list, entries):
+            if theoretical.size == 0 or ordered.size == 0 or theoretical.size != ordered.size:
+                ax.text(0.5, 0.5, "Invalid QQ data", ha='center', va='center')
+                ax.axis('off')
+                continue
+            ax.scatter(theoretical, ordered, s=12, alpha=0.7, color='tab:blue')
+            mean = float(np.mean(ordered))
+            std = float(np.std(ordered, ddof=1)) if ordered.size > 1 else 0.0
+            x_min = float(np.min(theoretical))
+            x_max = float(np.max(theoretical))
+            line_x = np.array([x_min, x_max], dtype=float)
+            if np.isfinite(std) and std > 0:
+                line_y = mean + std * line_x
+            else:
+                line_y = np.array([mean, mean], dtype=float)
+            ax.plot(line_x, line_y, color='red', linewidth=1)
+            ax.set_title(_column_label(col, base_name))
+            ax.set_xlabel('Theoretical quantiles')
+            ax.set_ylabel('Ordered values')
+
+        for ax in axes_list[len(entries):]:
+            ax.axis('off')
+
+        if base_name:
+            fig.suptitle(f"QQ plot: {base_name}")
+            plt.tight_layout(rect=(0, 0, 1, 0.95))
+        else:
+            plt.tight_layout()
+
+        plt.savefig(self._binary_image, format='png')
+        return self

iaml/plots/residual_plot.py

@@ -0,0 +1,38 @@
+"""
+[PLOT] Residuals Plot
+"""
+import textwrap
+
+from yellowbrick.regressor import ResidualsPlot as ybResidualsPlot
+
+from ..metric_plot import MetricPlot, yellowbrick_plot
+
+
+@yellowbrick_plot(ybResidualsPlot)
+class ResidualsPlot(MetricPlot):
+    """[PLOT] Residuals Plot"""
+
+    title: str = "Residuals Plot"
+    description: str = textwrap.dedent("""
+        The Residuals Plot is a diagnostic tool used to evaluate the performance of a regression model. 
+        In the context of predicting continuous medical outcomes, such as blood pressure, cholesterol levels, 
+        or other measurements, this plot helps assess how well the model's predictions match the actual 
+        observed values.
+
+        Residuals are the differences between the predicted values and the actual values. A well-performing 
+        regression model should have residuals that are randomly scattered around zero. Patterns in the residuals 
+        (such as curvature or clustering) can indicate that the model is not capturing certain relationships in 
+        the data.
+
+        For example, if you're building a model to predict a patient's cholesterol level based on various 
+        health metrics, the Residuals Plot would show whether the model consistently overestimates or underestimates 
+        values or if there are systematic errors.
+
+        Doctors and data scientists use this plot to detect whether the model is biased in its predictions and 
+        whether certain patterns or trends remain unexplained, which can be critical in refining models used 
+        for predicting medical outcomes.
+        """)
+
+    @classmethod
+    def suitable(cls, type_of_target: str) -> bool:
+        return type_of_target == 'continuous'

iaml/plots/roc_dynamique_curve_plot.py

@@ -0,0 +1,79 @@
+"""[PLOT] ROC Dynamique Curve for Survival Models using sksurv"""
+from __future__ import annotations
+
+import textwrap
+import io
+from typing import TYPE_CHECKING
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from sksurv.metrics import cumulative_dynamic_auc
+
+from ..metric_plot import MetricPlot, capture
+if TYPE_CHECKING:
+    from ..iaml_pipeline import IAMLPipeline
+
+
+class ROCDynamiqueCurvePlot(MetricPlot):
+    """[PLOT] ROC Dynamique Curve for Survival Models using sksurv"""
+
+    title: str = "ROC Dynamique Curve"
+    description: str = textwrap.dedent("""
+        This curve represents how well a predictive survival model is able to distinguish 
+        between patients who experience an event (like death or a heart attack) at different 
+        points in time and those who do not. The y-axis shows the AUC (Area Under the Curve), 
+        which is a measure of how good the model is at making this distinction—the closer to 1, 
+        the better the model performs. The x-axis represents time, showing different follow-up 
+        periods after the initial observation.
+
+        As time progresses, the curve helps us see if the model's predictions remain accurate 
+        or start to decline. For example, in a medical study predicting patient survival after 
+        a heart attack, this curve would indicate how well the model distinguishes between 
+        patients who pass away versus those who survive, over several months or years. 
+        A high AUC value means the model is very good at predicting outcomes, while a lower 
+        value suggests it struggles to differentiate between high-risk and low-risk patients as 
+        time goes on.""")
+
+    @capture
+    def compute(
+        self,
+        estimator: IAMLPipeline,
+        X: pd.DataFrame,
+        y: pd.Series,
+        X_train: pd.DataFrame = None,
+        y_train: pd.Series = None,
+        **kwargs) -> MetricPlot:
+        self._binary_image = io.BytesIO()
+
+        # Compute time-dependent ROC AUC for each time point
+        _, event_times = zip(*y)
+
+        max_val = max(event_times) - 0.1 if isinstance(max(event_times), float) \
+            else max(event_times)
+        times = np.arange(min(event_times), max_val)
+
+        # Calculate cumulative dynamic AUC (time-dependent ROC AUC)
+        aucs, _ = cumulative_dynamic_auc(
+            np.array(y_train, dtype=[('event', 'bool'), ('time', 'float')]),
+            np.array(y, dtype=[('event', 'bool'), ('time', 'float')]),
+            estimator.predict(X),
+            times
+        )
+
+        # Plot the time-dependent ROC AUC over time
+        plt.plot(times, aucs)
+        plt.xlabel("Temps de suivi")
+        plt.ylabel("AUC dynamique cumulative")
+        plt.title('ROC dynamique curve')
+        plt.ylim([0, 1])
+        plt.legend()
+        plt.grid(True)
+
+        plt.savefig(self._binary_image, format='png')
+        plt.close()
+
+        return self
+
+    @classmethod
+    def suitable(cls, type_of_target: str) -> bool:
+        return type_of_target == 'survival'