dragon-ml-toolbox 14.7.0__py3-none-any.whl → 16.2.0__py3-none-any.whl

ml_tools/ML_evaluation.py

@@ -24,7 +24,14 @@ import warnings
 from .path_manager import make_fullpath, sanitize_filename
 from ._logger import _LOGGER
 from ._script_info import _script_info
-from .keys import SHAPKeys, PyTorchLogKeys
+from ._keys import SHAPKeys, PyTorchLogKeys
+from .ML_configuration import (RegressionMetricsFormat,
+                               BinaryClassificationMetricsFormat,
+                               MultiClassClassificationMetricsFormat,
+                               BinaryImageClassificationMetricsFormat,
+                               MultiClassImageClassificationMetricsFormat,
+                               _BaseClassificationFormat,
+                               _BaseRegressionFormat)
 
 
 __all__ = [
@@ -41,6 +48,7 @@ DPI_value = 250
 def plot_losses(history: dict, save_dir: Union[str, Path]):
     """
     Plots training & validation loss curves from a history object.
+    Also plots the learning rate if available in the history.
 
     Args:
         history (dict): A dictionary containing 'train_loss' and 'val_loss'.
@@ -48,6 +56,7 @@ def plot_losses(history: dict, save_dir: Union[str, Path]):
     """
     train_loss = history.get(PyTorchLogKeys.TRAIN_LOSS, [])
     val_loss = history.get(PyTorchLogKeys.VAL_LOSS, [])
+    lr_history = history.get(PyTorchLogKeys.LEARNING_RATE, [])
     
     if not train_loss and not val_loss:
         _LOGGER.warning("Loss history is empty or incomplete. Cannot plot.")
@@ -55,22 +64,44 @@ def plot_losses(history: dict, save_dir: Union[str, Path]):
 
     fig, ax = plt.subplots(figsize=(10, 5), dpi=DPI_value)
     
+    # --- Plot Losses (Left Y-axis) ---
+    line_handles = [] # To store line objects for the legend
+    
     # Plot training loss only if data for it exists
     if train_loss:
         epochs = range(1, len(train_loss) + 1)
-        ax.plot(epochs, train_loss, 'o-', label='Training Loss')
+        line1, = ax.plot(epochs, train_loss, 'o-', label='Training Loss', color='tab:blue')
+        line_handles.append(line1)
     
     # Plot validation loss only if data for it exists
     if val_loss:
         epochs = range(1, len(val_loss) + 1)
-        ax.plot(epochs, val_loss, 'o-', label='Validation Loss')
+        line2, = ax.plot(epochs, val_loss, 'o-', label='Validation Loss', color='tab:orange')
+        line_handles.append(line2)
     
     ax.set_title('Training and Validation Loss')
     ax.set_xlabel('Epochs')
-    ax.set_ylabel('Loss')
-    ax.legend()
-    ax.grid(True)
-    plt.tight_layout()
+    ax.set_ylabel('Loss', color='tab:blue')
+    ax.tick_params(axis='y', labelcolor='tab:blue')
+    ax.grid(True, linestyle='--')
+    
+    # --- Plot Learning Rate (Right Y-axis) ---
+    if lr_history:
+        ax2 = ax.twinx() # Create a second y-axis
+        epochs = range(1, len(lr_history) + 1)
+        line3, = ax2.plot(epochs, lr_history, 'g--', label='Learning Rate')
+        line_handles.append(line3)
+        
+        ax2.set_ylabel('Learning Rate', color='g')
+        ax2.tick_params(axis='y', labelcolor='g')
+        # Use scientific notation if the LR is very small
+        ax2.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
+    
+    # Combine legends from both axes
+    ax.legend(handles=line_handles, loc='best')
+    
+    # ax.grid(True)
+    plt.tight_layout()    
     
     save_dir_path = make_fullpath(save_dir, make=True, enforce="directory")
     save_path = save_dir_path / "loss_plot.svg"
@@ -84,24 +115,30 @@ def classification_metrics(save_dir: Union[str, Path],
                            y_true: np.ndarray, 
                            y_pred: np.ndarray, 
                            y_prob: Optional[np.ndarray] = None, 
-                           cmap: str = "Blues", 
-                           class_map: Optional[dict[str,int]]=None, 
-                           ROC_PR_line: str='darkorange', 
-                           calibration_bins: int=15, 
-                           font_size: int=16):
+                           class_map: Optional[dict[str,int]] = None,
+                           config: Optional[Union[BinaryClassificationMetricsFormat,
+                                                MultiClassClassificationMetricsFormat,
+                                                BinaryImageClassificationMetricsFormat,
+                                                MultiClassImageClassificationMetricsFormat]] = None):
     """
     Saves classification metrics and plots.
 
     Args:
         y_true (np.ndarray): Ground truth labels.
         y_pred (np.ndarray): Predicted labels.
-        y_prob (np.ndarray, optional): Predicted probabilities for ROC curve.
-        cmap (str): Colormap for the confusion matrix.
+        y_prob (np.ndarray): Predicted probabilities for ROC curve.
+        config (object): Formatting configuration object.
         save_dir (str | Path): Directory to save plots.
-        class_map (dict[str, int], None): A map of {class_name: index} used to order and label the confusion matrix.
     """
+    # --- Parse Config or use defaults ---
+    if config is None:
+        # Create a default config if one wasn't provided
+        format_config = _BaseClassificationFormat()
+    else:
+        format_config = config
+    
     original_rc_params = plt.rcParams.copy()
-    plt.rcParams.update({'font.size': font_size})
+    plt.rcParams.update({'font.size': format_config.font_size})
     
     # print("--- Classification Report ---")
     
@@ -136,7 +173,7 @@ def classification_metrics(save_dir: Union[str, Path],
         sns.set_theme(font_scale=1.2) # Scale seaborn font
         sns.heatmap(pd.DataFrame(report_dict).iloc[:-1, :].T, 
                     annot=True, 
-                    cmap=cmap, 
+                    cmap=format_config.cmap, 
                     fmt='.2f',
                     vmin=0.0,
                     vmax=1.0)
@@ -158,7 +195,7 @@ def classification_metrics(save_dir: Union[str, Path],
     fig_cm, ax_cm = plt.subplots(figsize=(6, 6), dpi=DPI_value)
     disp_ = ConfusionMatrixDisplay.from_predictions(y_true, 
                                             y_pred, 
-                                            cmap=cmap, 
+                                            cmap=format_config.cmap, 
                                             ax=ax_cm, 
                                             normalize='true',
                                             labels=plot_labels,
@@ -171,7 +208,7 @@ def classification_metrics(save_dir: Union[str, Path],
     
     # Manually update font size of cell texts
     for text in ax_cm.texts:
-        text.set_fontsize(font_size)
+        text.set_fontsize(format_config.font_size)
 
     fig_cm.tight_layout()
     
@@ -196,10 +233,10 @@ def classification_metrics(save_dir: Union[str, Path],
             class_indices_to_plot = [1]
             plot_titles = [""] # No extra title
             save_suffixes = [""] # No extra suffix
-            _LOGGER.info("Generating binary classification plots (ROC, PR, Calibration).")
+            _LOGGER.debug("Generating binary classification plots (ROC, PR, Calibration).")
         
         elif num_classes > 2:
-            _LOGGER.info(f"Generating One-vs-Rest plots for {num_classes} classes.")
+            _LOGGER.debug(f"Generating One-vs-Rest plots for {num_classes} classes.")
             # Multiclass case: Plot for every class (One-vs-Rest)
             class_indices_to_plot = list(range(num_classes))
             
@@ -234,17 +271,54 @@ def classification_metrics(save_dir: Union[str, Path],
             
             # Binarize y_true for the current class
             y_true_binary = (y_true == class_index).astype(int)
-
+            
             # --- Save ROC Curve ---
-            fpr, tpr, _ = roc_curve(y_true_binary, y_score)
+            fpr, tpr, thresholds = roc_curve(y_true_binary, y_score)
+            
+            try:
+                # Calculate Youden's J statistic (tpr - fpr)
+                J = tpr - fpr
+                # Find the index of the best threshold
+                best_index = np.argmax(J)
+                optimal_threshold = thresholds[best_index]
+                
+                # Define the filename
+                threshold_filename = f"best_threshold{save_suffix}.txt"
+                threshold_path = save_dir_path / threshold_filename
+                
+                # Get the class name for the report
+                class_name = ""
+                # Check if we have display labels and the current index is valid
+                if map_display_labels and class_index < len(map_display_labels):
+                    class_name = map_display_labels[class_index]
+                    if num_classes > 2:
+                        # Add 'vs. Rest' for multiclass one-vs-rest plots
+                        class_name += " (vs. Rest)"
+                else:
+                    # Fallback to the generic title or default binary name
+                    class_name = plot_title.strip() or "Binary Positive Class"
+                
+                # Create content for the file
+                file_content = (
+                    f"Optimal Classification Threshold (Youden's J Statistic)\n"
+                    f"Class: {class_name}\n"
+                    f"--------------------------------------------------\n"
+                    f"Threshold: {optimal_threshold:.6f}\n"
+                    f"True Positive Rate (TPR): {tpr[best_index]:.6f}\n"
+                    f"False Positive Rate (FPR): {fpr[best_index]:.6f}\n"
+                )
+                
+                threshold_path.write_text(file_content, encoding="utf-8")
+                _LOGGER.info(f"💾 Optimal threshold saved as '{threshold_path.name}'")
+
+            except Exception as e:
+                _LOGGER.warning(f"Could not calculate or save optimal threshold: {e}")
             
             # Calculate AUC. 
-            # Note: For multiclass, roc_auc_score(y_true, y_prob, multi_class='ovr') could average, but plotting individual curves is more informative.
-            # Here we calculate the specific AUC for the binarized problem.
             auc = roc_auc_score(y_true_binary, y_score) 
             
             fig_roc, ax_roc = plt.subplots(figsize=(6, 6), dpi=DPI_value)
-            ax_roc.plot(fpr, tpr, label=f'AUC = {auc:.2f}', color=ROC_PR_line)
+            ax_roc.plot(fpr, tpr, label=f'AUC = {auc:.2f}', color=format_config.ROC_PR_line)
             ax_roc.plot([0, 1], [0, 1], 'k--')
             ax_roc.set_title(f'Receiver Operating Characteristic{plot_title}')
             ax_roc.set_xlabel('False Positive Rate')
@@ -259,7 +333,7 @@ def classification_metrics(save_dir: Union[str, Path],
             precision, recall, _ = precision_recall_curve(y_true_binary, y_score)
             ap_score = average_precision_score(y_true_binary, y_score)
             fig_pr, ax_pr = plt.subplots(figsize=(6, 6), dpi=DPI_value)
-            ax_pr.plot(recall, precision, label=f'Avg Precision = {ap_score:.2f}', color=ROC_PR_line)
+            ax_pr.plot(recall, precision, label=f'Avg Precision = {ap_score:.2f}', color=format_config.ROC_PR_line)
             ax_pr.set_title(f'Precision-Recall Curve{plot_title}')
             ax_pr.set_xlabel('Recall')
             ax_pr.set_ylabel('Precision')
@@ -278,7 +352,7 @@ def classification_metrics(save_dir: Union[str, Path],
                 cal_display_temp = CalibrationDisplay.from_predictions(
                     y_true_binary, # Use binarized labels
                     y_score, 
-                    n_bins=calibration_bins, 
+                    n_bins=format_config.calibration_bins, 
                     ax=ax_temp,
                     name="temp" # Add a name to suppress potential warnings
                 )
@@ -294,9 +368,9 @@ def classification_metrics(save_dir: Union[str, Path],
                 y=line_y,
                 ax=ax_cal,
                 scatter=False, 
-                label=f"Calibration Curve ({calibration_bins} bins)",
+                label=f"Calibration Curve ({format_config.calibration_bins} bins)",
                 line_kws={
-                    'color': ROC_PR_line, 
+                    'color': format_config.ROC_PR_line, 
                     'linestyle': '--', 
                     'linewidth': 2,
                     }
@@ -324,7 +398,12 @@ def classification_metrics(save_dir: Union[str, Path],
     plt.rcParams.update(original_rc_params)
 
 
-def regression_metrics(y_true: np.ndarray, y_pred: np.ndarray, save_dir: Union[str, Path]):
+def regression_metrics(
+    y_true: np.ndarray, 
+    y_pred: np.ndarray, 
+    save_dir: Union[str, Path],
+    config: Optional[RegressionMetricsFormat] = None
+):
     """
     Saves regression metrics and plots.
 
@@ -332,7 +411,21 @@ def regression_metrics(y_true: np.ndarray, y_pred: np.ndarray, save_dir: Union[s
         y_true (np.ndarray): Ground truth values.
         y_pred (np.ndarray): Predicted values.
         save_dir (str | Path): Directory to save plots and report.
+        config (RegressionMetricsFormat, optional): Formatting configuration object.
     """
+    
+    # --- Parse Config or use defaults ---
+    if config is None:
+        # Create a default config if one wasn't provided
+        format_config = _BaseRegressionFormat()
+    else:
+        format_config = config
+        
+    # --- Set Matplotlib font size ---
+    original_rc_params = plt.rcParams.copy()
+    plt.rcParams.update({'font.size': format_config.font_size})
+    
+    # --- Calculate Metrics ---
     rmse = np.sqrt(mean_squared_error(y_true, y_pred))
     mae = mean_absolute_error(y_true, y_pred)
     r2 = r2_score(y_true, y_pred)
@@ -354,11 +447,13 @@ def regression_metrics(y_true: np.ndarray, y_pred: np.ndarray, save_dir: Union[s
     report_path.write_text(report_string)
     _LOGGER.info(f"📝 Regression report saved as '{report_path.name}'")
 
-    # Save residual plot
+    # --- Save residual plot ---
     residuals = y_true - y_pred
     fig_res, ax_res = plt.subplots(figsize=(8, 6), dpi=DPI_value)
-    ax_res.scatter(y_pred, residuals, alpha=0.6)
-    ax_res.axhline(0, color='red', linestyle='--')
+    ax_res.scatter(y_pred, residuals, 
+                   alpha=format_config.scatter_alpha, 
+                   color=format_config.scatter_color)
+    ax_res.axhline(0, color=format_config.residual_line_color, linestyle='--')
     ax_res.set_xlabel("Predicted Values")
     ax_res.set_ylabel("Residuals")
     ax_res.set_title("Residual Plot")
@@ -369,10 +464,15 @@ def regression_metrics(y_true: np.ndarray, y_pred: np.ndarray, save_dir: Union[s
     _LOGGER.info(f"📈 Residual plot saved as '{res_path.name}'")
     plt.close(fig_res)
 
-    # Save true vs predicted plot
+    # --- Save true vs predicted plot ---
     fig_tvp, ax_tvp = plt.subplots(figsize=(8, 6), dpi=DPI_value)
-    ax_tvp.scatter(y_true, y_pred, alpha=0.6)
-    ax_tvp.plot([y_true.min(), y_true.max()], [y_true.min(), y_true.max()], 'k--', lw=2)
+    ax_tvp.scatter(y_true, y_pred, 
+                   alpha=format_config.scatter_alpha, 
+                   color=format_config.scatter_color)
+    ax_tvp.plot([y_true.min(), y_true.max()], [y_true.min(), y_true.max()], 
+                linestyle='--', 
+                lw=2,
+                color=format_config.ideal_line_color)
     ax_tvp.set_xlabel('True Values')
     ax_tvp.set_ylabel('Predictions')
     ax_tvp.set_title('True vs. Predicted Values')
@@ -383,9 +483,11 @@ def regression_metrics(y_true: np.ndarray, y_pred: np.ndarray, save_dir: Union[s
     _LOGGER.info(f"📉 True vs. Predicted plot saved as '{tvp_path.name}'")
     plt.close(fig_tvp)
     
-    # Save Histogram of Residuals
+    # --- Save Histogram of Residuals ---
     fig_hist, ax_hist = plt.subplots(figsize=(8, 6), dpi=DPI_value)
-    sns.histplot(residuals, kde=True, ax=ax_hist)
+    sns.histplot(residuals, kde=True, ax=ax_hist, 
+                 bins=format_config.hist_bins, 
+                 color=format_config.scatter_color)
     ax_hist.set_xlabel("Residual Value")
     ax_hist.set_ylabel("Frequency")
     ax_hist.set_title("Distribution of Residuals")
@@ -396,6 +498,9 @@ def regression_metrics(y_true: np.ndarray, y_pred: np.ndarray, save_dir: Union[s
     _LOGGER.info(f"📊 Residuals histogram saved as '{hist_path.name}'")
     plt.close(fig_hist)
     
+    # --- Restore RC params ---
+    plt.rcParams.update(original_rc_params)
+    
 
 def shap_summary_plot(model, 
                       background_data: Union[torch.Tensor,np.ndarray], 

ml_tools/ML_evaluation_multi.py

@@ -19,13 +19,17 @@ from sklearn.metrics import (
     jaccard_score
 )
 from pathlib import Path
-from typing import Union, List, Literal
+from typing import Union, List, Literal, Optional
 import warnings
 
 from .path_manager import make_fullpath, sanitize_filename
 from ._logger import _LOGGER
 from ._script_info import _script_info
-from .keys import SHAPKeys
+from ._keys import SHAPKeys
+from .ML_configuration import (MultiTargetRegressionMetricsFormat,
+                               _BaseRegressionFormat,
+                               MultiLabelBinaryClassificationMetricsFormat,
+                               _BaseMultiLabelFormat)
 
 
 __all__ = [
@@ -41,7 +45,8 @@ def multi_target_regression_metrics(
     y_true: np.ndarray,
     y_pred: np.ndarray,
     target_names: List[str],
-    save_dir: Union[str, Path]
+    save_dir: Union[str, Path],
+    config: Optional[MultiTargetRegressionMetricsFormat] = None
 ):
     """
     Calculates and saves regression metrics for each target individually.
@@ -55,6 +60,7 @@ def multi_target_regression_metrics(
         y_pred (np.ndarray): Predicted values, shape (n_samples, n_targets).
         target_names (List[str]): A list of names for the target variables.
         save_dir (str | Path): Directory to save plots and the report.
+        config (object): Formatting configuration object.
     """
     if y_true.ndim != 2 or y_pred.ndim != 2:
         _LOGGER.error("y_true and y_pred must be 2D arrays for multi-target regression.")
@@ -68,8 +74,19 @@ def multi_target_regression_metrics(
 
     save_dir_path = make_fullpath(save_dir, make=True, enforce="directory")
     metrics_summary = []
+    
+    # --- Parse Config or use defaults ---
+    if config is None:
+        # Create a default config if one wasn't provided
+        format_config = _BaseRegressionFormat()
+    else:
+        format_config = config
+
+    # --- Set Matplotlib font size ---
+    original_rc_params = plt.rcParams.copy()
+    plt.rcParams.update({'font.size': format_config.font_size})
 
-    _LOGGER.info("--- Multi-Target Regression Evaluation ---")
+    _LOGGER.debug("--- Multi-Target Regression Evaluation ---")
 
     for i, name in enumerate(target_names):
         print(f"  -> Evaluating target: '{name}'")
@@ -93,8 +110,12 @@ def multi_target_regression_metrics(
         # --- Save Residual Plot ---
         residuals = true_i - pred_i
         fig_res, ax_res = plt.subplots(figsize=(8, 6), dpi=DPI_value)
-        ax_res.scatter(pred_i, residuals, alpha=0.6, edgecolors='k', s=50)
-        ax_res.axhline(0, color='red', linestyle='--')
+        ax_res.scatter(pred_i, residuals, 
+                       alpha=format_config.scatter_alpha, 
+                       edgecolors='k', 
+                       s=50,
+                       color=format_config.scatter_color) # Use config color
+        ax_res.axhline(0, color=format_config.residual_line_color, linestyle='--') # Use config color
         ax_res.set_xlabel("Predicted Values")
         ax_res.set_ylabel("Residuals (True - Predicted)")
         ax_res.set_title(f"Residual Plot for '{name}'")
@@ -106,8 +127,15 @@ def multi_target_regression_metrics(
 
         # --- Save True vs. Predicted Plot ---
         fig_tvp, ax_tvp = plt.subplots(figsize=(8, 6), dpi=DPI_value)
-        ax_tvp.scatter(true_i, pred_i, alpha=0.6, edgecolors='k', s=50)
-        ax_tvp.plot([true_i.min(), true_i.max()], [true_i.min(), true_i.max()], 'k--', lw=2)
+        ax_tvp.scatter(true_i, pred_i, 
+                       alpha=format_config.scatter_alpha, 
+                       edgecolors='k', 
+                       s=50,
+                       color=format_config.scatter_color) # Use config color
+        ax_tvp.plot([true_i.min(), true_i.max()], [true_i.min(), true_i.max()], 
+                    linestyle='--', 
+                    lw=2,
+                    color=format_config.ideal_line_color) # Use config color
         ax_tvp.set_xlabel('True Values')
         ax_tvp.set_ylabel('Predicted Values')
         ax_tvp.set_title(f'True vs. Predicted Values for "{name}"')
@@ -122,17 +150,18 @@ def multi_target_regression_metrics(
     report_path = save_dir_path / "regression_report_multi.csv"
     summary_df.to_csv(report_path, index=False)
     _LOGGER.info(f"Full regression report saved to '{report_path.name}'")
+    
+    # --- Restore RC params ---
+    plt.rcParams.update(original_rc_params)
 
 
 def multi_label_classification_metrics(
     y_true: np.ndarray,
+    y_pred: np.ndarray,
     y_prob: np.ndarray,
     target_names: List[str],
     save_dir: Union[str, Path],
-    threshold: float = 0.5,
-    ROC_PR_line: str='darkorange',
-    cmap: str = "Blues",
-    font_size: int = 16
+    config: Optional[MultiLabelBinaryClassificationMetricsFormat] = None
 ):
     """
     Calculates and saves classification metrics for each label individually.
@@ -143,17 +172,17 @@ def multi_label_classification_metrics(
 
     Args:
         y_true (np.ndarray): Ground truth binary labels, shape (n_samples, n_labels).
+        y_pred (np.ndarray): Predicted binary labels, shape (n_samples, n_labels).
         y_prob (np.ndarray): Predicted probabilities, shape (n_samples, n_labels).
         target_names (List[str]): A list of names for the labels.
         save_dir (str | Path): Directory to save plots and reports.
-        threshold (float): The probability threshold to convert probabilities into
-                           binary predictions for metrics like the confusion matrix.
+        config (object): Formatting configuration object.
     """
-    if y_true.ndim != 2 or y_prob.ndim != 2:
-        _LOGGER.error("y_true and y_prob must be 2D arrays for multi-label classification.")
+    if y_true.ndim != 2 or y_prob.ndim != 2 or y_pred.ndim != 2:
+        _LOGGER.error("y_true, y_pred, and y_prob must be 2D arrays for multi-label classification.")
         raise ValueError()
-    if y_true.shape != y_prob.shape:
-        _LOGGER.error("Shapes of y_true and y_prob must match.")
+    if y_true.shape != y_prob.shape or y_true.shape != y_pred.shape:
+        _LOGGER.error("Shapes of y_true, y_pred, and y_prob must match.")
         raise ValueError()
     if y_true.shape[1] != len(target_names):
         _LOGGER.error("Number of target names must match the number of columns in y_true.")
@@ -161,22 +190,28 @@ def multi_label_classification_metrics(
 
     save_dir_path = make_fullpath(save_dir, make=True, enforce="directory")
     
-    # Generate binary predictions from probabilities
-    y_pred = (y_prob >= threshold).astype(int)
+    # --- Parse Config or use defaults ---
+    if config is None:
+        # Create a default config if one wasn't provided
+        format_config = _BaseMultiLabelFormat()
+    else:
+        format_config = config
+    
+    # y_pred is now passed in directly, no threshold needed.
     
     # --- Save current RC params and update font size ---
     original_rc_params = plt.rcParams.copy()
-    plt.rcParams.update({'font.size': font_size})
+    plt.rcParams.update({'font.size': format_config.font_size})
 
-    _LOGGER.info("--- Multi-Label Classification Evaluation ---")
+    # _LOGGER.info("--- Multi-Label Classification Evaluation ---")
 
-    # --- Calculate and Save Overall Metrics ---
+    # --- Calculate and Save Overall Metrics (using y_pred) ---
     h_loss = hamming_loss(y_true, y_pred)
     j_score_micro = jaccard_score(y_true, y_pred, average='micro')
     j_score_macro = jaccard_score(y_true, y_pred, average='macro')
 
     overall_report = (
-        f"Overall Multi-Label Metrics (Threshold = {threshold}):\n"
+        f"Overall Multi-Label Metrics:\n" # No threshold to report here
         f"--------------------------------------------------\n"
         f"Hamming Loss: {h_loss:.4f}\n"
         f"Jaccard Score (micro): {j_score_micro:.4f}\n"
@@ -191,20 +226,20 @@ def multi_label_classification_metrics(
     for i, name in enumerate(target_names):
         print(f"  -> Evaluating label: '{name}'")
         true_i = y_true[:, i]
-        pred_i = y_pred[:, i]
-        prob_i = y_prob[:, i]
+        pred_i = y_pred[:, i] # Use passed-in y_pred
+        prob_i = y_prob[:, i] # Use passed-in y_prob
         sanitized_name = sanitize_filename(name)
 
-        # --- Save Classification Report for the label ---
+        # --- Save Classification Report for the label (uses y_pred) ---
         report_text = classification_report(true_i, pred_i)
         report_path = save_dir_path / f"classification_report_{sanitized_name}.txt"
         report_path.write_text(report_text) # type: ignore
 
-        # --- Save Confusion Matrix ---
+        # --- Save Confusion Matrix (uses y_pred) ---
         fig_cm, ax_cm = plt.subplots(figsize=(6, 6), dpi=DPI_value)
         disp_ = ConfusionMatrixDisplay.from_predictions(true_i, 
                                                 pred_i, 
-                                                cmap=cmap, 
+                                                cmap=format_config.cmap, # Use config cmap
                                                 ax=ax_cm, 
                                                 normalize='true',
                                                 labels=[0, 1],
@@ -217,7 +252,7 @@ def multi_label_classification_metrics(
         
         # Manually update font size of cell texts
         for text in ax_cm.texts:
-            text.set_fontsize(font_size)
+            text.set_fontsize(format_config.font_size) # Use config font_size
 
         fig_cm.tight_layout()
         
@@ -226,11 +261,44 @@ def multi_label_classification_metrics(
         plt.savefig(cm_path)
         plt.close(fig_cm)
 
-        # --- Save ROC Curve ---
-        fpr, tpr, _ = roc_curve(true_i, prob_i)
+        # --- Save ROC Curve (uses y_prob) ---
+        fpr, tpr, thresholds = roc_curve(true_i, prob_i)
+        
+        try:
+            # Calculate Youden's J statistic (tpr - fpr)
+            J = tpr - fpr
+            # Find the index of the best threshold
+            best_index = np.argmax(J)
+            optimal_threshold = thresholds[best_index]
+            best_tpr = tpr[best_index]
+            best_fpr = fpr[best_index]
+            
+            # Define the filename
+            threshold_filename = f"best_threshold_{sanitized_name}.txt"
+            threshold_path = save_dir_path / threshold_filename
+            
+            # The class name is the target_name for this label
+            class_name = name 
+            
+            # Create content for the file
+            file_content = (
+                f"Optimal Classification Threshold (Youden's J Statistic)\n"
+                f"Class/Label: {class_name}\n"
+                f"--------------------------------------------------\n"
+                f"Threshold: {optimal_threshold:.6f}\n"
+                f"True Positive Rate (TPR): {best_tpr:.6f}\n"
+                f"False Positive Rate (FPR): {best_fpr:.6f}\n"
+            )
+            
+            threshold_path.write_text(file_content, encoding="utf-8")
+            _LOGGER.info(f"💾 Optimal threshold for '{name}' saved to '{threshold_path.name}'")
+
+        except Exception as e:
+            _LOGGER.warning(f"Could not calculate or save optimal threshold for '{name}': {e}")
+        
         auc = roc_auc_score(true_i, prob_i)
         fig_roc, ax_roc = plt.subplots(figsize=(6, 6), dpi=DPI_value)
-        ax_roc.plot(fpr, tpr, label=f'AUC = {auc:.2f}', color=ROC_PR_line)
+        ax_roc.plot(fpr, tpr, label=f'AUC = {auc:.2f}', color=format_config.ROC_PR_line) # Use config color
         ax_roc.plot([0, 1], [0, 1], 'k--')
         ax_roc.set_title(f'ROC Curve for "{name}"')
         ax_roc.set_xlabel('False Positive Rate'); ax_roc.set_ylabel('True Positive Rate')
@@ -239,11 +307,11 @@ def multi_label_classification_metrics(
         plt.savefig(roc_path)
         plt.close(fig_roc)
 
-        # --- Save Precision-Recall Curve ---
+        # --- Save Precision-Recall Curve (uses y_prob) ---
         precision, recall, _ = precision_recall_curve(true_i, prob_i)
         ap_score = average_precision_score(true_i, prob_i)
         fig_pr, ax_pr = plt.subplots(figsize=(6, 6), dpi=DPI_value)
-        ax_pr.plot(recall, precision, label=f'AP = {ap_score:.2f}', color=ROC_PR_line)
+        ax_pr.plot(recall, precision, label=f'AP = {ap_score:.2f}', color=format_config.ROC_PR_line) # Use config color
         ax_pr.set_title(f'Precision-Recall Curve for "{name}"')
         ax_pr.set_xlabel('Recall'); ax_pr.set_ylabel('Precision')
         ax_pr.legend(loc='lower left'); ax_pr.grid(True, linestyle='--', alpha=0.6)