dragon-ml-toolbox 20.7.1__tar.gz → 20.8.0__tar.gz

{dragon_ml_toolbox-20.7.1/dragon_ml_toolbox.egg-info → dragon_ml_toolbox-20.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 20.7.1
+Version: 20.8.0
 Summary: Complete pipelines and helper tools for data science and machine learning projects.
 Author-email: Karl Luigi Loza Vidaurre <luigiloza@gmail.com>
 License-Expression: MIT
@@ -174,6 +174,7 @@ ML_vision_transformers
 optimization_tools
 path_manager
 plot_fonts
+resampling
 schema
 serde
 SQL
@@ -206,6 +207,7 @@ optimization_tools
 path_manager
 plot_fonts
 PSO_optimization
+resampling
 schema
 serde
 SQL

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0}/README.md

@@ -81,6 +81,7 @@ ML_vision_transformers
 optimization_tools
 path_manager
 plot_fonts
+resampling
 schema
 serde
 SQL
@@ -113,6 +114,7 @@ optimization_tools
 path_manager
 plot_fonts
 PSO_optimization
+resampling
 schema
 serde
 SQL

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0/dragon_ml_toolbox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragon-ml-toolbox
-Version: 20.7.1
+Version: 20.8.0
 Summary: Complete pipelines and helper tools for data science and machine learning projects.
 Author-email: Karl Luigi Loza Vidaurre <luigiloza@gmail.com>
 License-Expression: MIT
@@ -174,6 +174,7 @@ ML_vision_transformers
 optimization_tools
 path_manager
 plot_fonts
+resampling
 schema
 serde
 SQL
@@ -206,6 +207,7 @@ optimization_tools
 path_manager
 plot_fonts
 PSO_optimization
+resampling
 schema
 serde
 SQL

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0}/dragon_ml_toolbox.egg-info/SOURCES.txt

@@ -136,6 +136,10 @@ ml_tools/path_manager/_dragonmanager.py
 ml_tools/path_manager/_path_tools.py
 ml_tools/plot_fonts/__init__.py
 ml_tools/plot_fonts/_plot_fonts.py
+ml_tools/resampling/__init__.py
+ml_tools/resampling/_base_resampler.py
+ml_tools/resampling/_multi_resampling.py
+ml_tools/resampling/_single_resampling.py
 ml_tools/schema/__init__.py
 ml_tools/schema/_feature_schema.py
 ml_tools/schema/_gui_schema.py

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0}/ml_tools/ML_configuration/_metrics.py

@@ -98,10 +98,11 @@ class _BaseMultiLabelFormat:
                  cmap: str = "BuGn",
                  ROC_PR_line: str='darkorange',
                  calibration_bins: Union[int, Literal['auto']]='auto', 
-                 font_size: int = 25,
-                 xtick_size: int=20,
-                 ytick_size: int=20,
-                 legend_size: int=23) -> None:
+                 font_size: int = 26,
+                 xtick_size: int=22,
+                 ytick_size: int=22,
+                 legend_size: int=26,
+                 cm_font_size: int=26) -> None:
         """
         Initializes the formatting configuration for multi-label classification metrics.
 
@@ -127,6 +128,8 @@ class _BaseMultiLabelFormat:
             
             legend_size (int): Font size for plot legends.
             
+            cm_font_size (int): Font size for the confusion matrix.
+            
         <br>
         
         ### [Matplotlib Colormaps](https://matplotlib.org/stable/users/explain/colors/colormaps.html)
@@ -142,6 +145,7 @@ class _BaseMultiLabelFormat:
         self.xtick_size = xtick_size
         self.ytick_size = ytick_size
         self.legend_size = legend_size
+        self.cm_font_size = cm_font_size
         
     def __repr__(self) -> str:
         parts = [
@@ -151,7 +155,8 @@ class _BaseMultiLabelFormat:
             f"font_size={self.font_size}",
             f"xtick_size={self.xtick_size}",
             f"ytick_size={self.ytick_size}",
-            f"legend_size={self.legend_size}"
+            f"legend_size={self.legend_size}",
+            f"cm_font_size={self.cm_font_size}"
         ]
         return f"{self.__class__.__name__}({', '.join(parts)})"
 
@@ -520,10 +525,11 @@ class FormatMultiLabelBinaryClassificationMetrics(_BaseMultiLabelFormat):
                  cmap: str = "BuGn",
                  ROC_PR_line: str='darkorange',
                  calibration_bins: Union[int, Literal['auto']]='auto', 
-                 font_size: int = 25,
-                 xtick_size: int=20,
-                 ytick_size: int=20,
-                 legend_size: int=23
+                 font_size: int = 26,
+                 xtick_size: int=22,
+                 ytick_size: int=22,
+                 legend_size: int=26,
+                 cm_font_size: int=26
                  ) -> None:
         super().__init__(cmap=cmap,
                          ROC_PR_line=ROC_PR_line, 
@@ -531,7 +537,8 @@ class FormatMultiLabelBinaryClassificationMetrics(_BaseMultiLabelFormat):
                          font_size=font_size,
                          xtick_size=xtick_size,
                          ytick_size=ytick_size,
-                         legend_size=legend_size)
+                         legend_size=legend_size,
+                         cm_font_size=cm_font_size)
 
 
 # Segmentation

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0}/ml_tools/ML_evaluation/_classification.py

@@ -481,6 +481,10 @@ def multi_label_classification_metrics(
     ytick_size = format_config.ytick_size
     legend_size = format_config.legend_size
     base_font_size = format_config.font_size
+    
+    # config font size for heatmap
+    cm_font_size = format_config.cm_font_size
+    cm_tick_size = cm_font_size - 4
 
     # --- Calculate and Save Overall Metrics (using y_pred) ---
     h_loss = hamming_loss(y_true, y_pred)
@@ -488,7 +492,7 @@ def multi_label_classification_metrics(
     j_score_macro = jaccard_score(y_true, y_pred, average='macro')
 
     overall_report = (
-        f"Overall Multi-Label Metrics:\n" # No threshold to report here
+        f"Overall Multi-Label Metrics:\n"
         f"--------------------------------------------------\n"
         f"Hamming Loss: {h_loss:.4f}\n"
         f"Jaccard Score (micro): {j_score_micro:.4f}\n"
@@ -498,14 +502,82 @@ def multi_label_classification_metrics(
     # print(overall_report)
     overall_report_path = save_dir_path / "classification_report.txt"
     overall_report_path.write_text(overall_report)
+    
+    # --- Save Classification Report Heatmap (Multi-label) ---
+    try:
+         # Generate full report as dict
+        full_report_dict = classification_report(y_true, y_pred, target_names=target_names, output_dict=True)
+        report_df = pd.DataFrame(full_report_dict)
+        
+        # Cleanup
+        # Remove 'accuracy' column if it exists 
+        report_df = report_df.drop(columns=['accuracy'], errors='ignore')
+        
+        # Remove 'support' row explicitly
+        if 'support' in report_df.index:
+            report_df = report_df.drop(index='support')
+            
+        # Transpose: Rows = Classes/Averages, Cols = Metrics
+        plot_df = report_df.T
+        
+        # Dynamic Height
+        fig_height = max(5.0, len(plot_df.index) * 0.5 + 4.0)
+        fig_width = 8.0 
+
+        fig_heat, ax_heat = plt.subplots(figsize=(fig_width, fig_height), dpi=_EvaluationConfig.DPI)
+
+        # Plot
+        sns.heatmap(plot_df, 
+                    annot=True, 
+                    cmap=format_config.cmap, 
+                    fmt='.2f',
+                    vmin=0.0,
+                    vmax=1.0,
+                    cbar_kws={'shrink': 0.9})
+        
+        ax_heat.set_title("Classification Report Heatmap", pad=_EvaluationConfig.LABEL_PADDING, fontsize=cm_font_size)
+        
+        # manually increase the font size of the elements
+        for text in ax_heat.texts:
+            text.set_fontsize(cm_tick_size)
+
+        cbar = ax_heat.collections[0].colorbar
+        cbar.ax.tick_params(labelsize=cm_tick_size - 4) # type: ignore
+
+        ax_heat.tick_params(axis='x', labelsize=cm_tick_size, pad=_EvaluationConfig.LABEL_PADDING)
+        ax_heat.tick_params(axis='y', labelsize=cm_tick_size, pad=_EvaluationConfig.LABEL_PADDING, rotation=0)
+
+        plt.tight_layout()
+        heatmap_path = save_dir_path / "classification_report_heatmap.svg"
+        plt.savefig(heatmap_path)
+        _LOGGER.info(f"📊 Report heatmap saved as '{heatmap_path.name}'")
+        plt.close(fig_heat)
+
+    except Exception as e:
+        _LOGGER.error(f"Could not generate multi-label classification report heatmap: {e}")
 
     # --- Per-Label Metrics and Plots ---
     for i, name in enumerate(target_names):
-        print(f"  -> Evaluating label: '{name}'")
+        # strip whitespace from name
+        name = name.strip()
+        
+        # print(f"  -> Evaluating label: '{name}'")
         true_i = y_true[:, 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)
+        
+        # if name is too long, just take the first letter of each word. Each word might be separated by space or underscore
+        if len(name) >= _EvaluationConfig.NAME_LIMIT:
+            parts = [w for w in name.replace("_", " ").split() if w]
+            abbr = "".join(p[0].upper() for p in parts)
+            # keep only alpha numeric chars
+            abbr = "".join(ch for ch in abbr if ch.isalnum())
+            if not abbr:
+                # fallback to a sanitized, truncated version of the original name
+                abbr = sanitize_filename(name)[: _EvaluationConfig.NAME_LIMIT]
+            _LOGGER.warning(f"Using abbreviated name '{abbr}' for '{name}' plots.")
+            name = abbr
 
         # --- Save Classification Report for the label (uses y_pred) ---
         report_text = classification_report(true_i, pred_i)
@@ -537,7 +609,7 @@ def multi_label_classification_metrics(
         ax_cm.tick_params(axis='y', labelsize=ytick_size)
         
         # Set titles and labels with padding
-        ax_cm.set_title(f"Confusion Matrix for '{name}'", pad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size + 2)
+        ax_cm.set_title(f"Confusion Matrix - {name}", pad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size + 2)
         ax_cm.set_xlabel(ax_cm.get_xlabel(), labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size)
         ax_cm.set_ylabel(ax_cm.get_ylabel(), labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size)
         
@@ -594,7 +666,7 @@ def multi_label_classification_metrics(
         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}"', pad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size + 2)
+        ax_roc.set_title(f'ROC Curve - {name}', pad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size + 2)
         ax_roc.set_xlabel('False Positive Rate', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size)
         ax_roc.set_ylabel('True Positive Rate', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size)
         
@@ -616,7 +688,7 @@ def multi_label_classification_metrics(
         ap_score = average_precision_score(true_i, prob_i)
         fig_pr, ax_pr = plt.subplots(figsize=CLASSIFICATION_PLOT_SIZE, dpi=DPI_value)
         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}"', pad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size + 2)
+        ax_pr.set_title(f'PR Curve - {name}', pad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size + 2)
         ax_pr.set_xlabel('Recall', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size)
         ax_pr.set_ylabel('Precision', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size)
         
@@ -659,10 +731,10 @@ def multi_label_classification_metrics(
                     prob_true, 
                     marker='o',
                     linewidth=2, 
-                    label=f"Calibration for '{name}'", 
+                    label=f"Model Calibration", 
                     color=format_config.ROC_PR_line)
         
-        ax_cal.set_title(f'Reliability Curve for "{name}"', pad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size + 2)
+        ax_cal.set_title(f'Calibration - {name}', pad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size + 2)
         ax_cal.set_xlabel('Mean Predicted Probability', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size)
         ax_cal.set_ylabel('Fraction of Positives', labelpad=_EvaluationConfig.LABEL_PADDING, fontsize=base_font_size)
         

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0}/ml_tools/data_exploration/__init__.py

@@ -2,6 +2,7 @@ from ._analysis import (
     summarize_dataframe,
     show_null_columns,
     match_and_filter_columns_by_regex,
+    check_class_balance,
 )
 
 from ._cleaning import (
@@ -28,6 +29,7 @@ from ._features import (
     split_continuous_binary,
     split_continuous_categorical_targets,
     encode_categorical_features,
+    encode_classification_target,
     reconstruct_one_hot,
     reconstruct_binary,
     reconstruct_multibinary,
@@ -44,7 +46,6 @@ from .._core import _imprimir_disponibles
 
 __all__ = [
     "summarize_dataframe",
-    "show_null_columns",
     "drop_constant_columns",
     "drop_rows_with_missing_data",
     "drop_columns_with_missing_data",
@@ -61,10 +62,13 @@ __all__ = [
     "plot_categorical_vs_target",
     "plot_correlation_heatmap", 
     "encode_categorical_features",
+    "encode_classification_target",
     "finalize_feature_schema",
     "apply_feature_schema",
     "reconstruct_from_schema",
     "match_and_filter_columns_by_regex",
+    "show_null_columns",
+    "check_class_balance",
     "standardize_percentages",
     "reconstruct_one_hot",
     "reconstruct_binary",

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0}/ml_tools/data_exploration/_analysis.py

@@ -16,6 +16,7 @@ __all__ = [
     "summarize_dataframe",
     "show_null_columns",
     "match_and_filter_columns_by_regex",
+    "check_class_balance",
 ]
 
 
@@ -212,3 +213,151 @@ def match_and_filter_columns_by_regex(
 
     return filtered_df, matched_columns
 
+
+def check_class_balance(
+    df: pd.DataFrame,
+    target: Union[str, list[str]],
+    plot_to_dir: Optional[Union[str, Path]] = None,
+    plot_filename: str = "Class_Balance"
+) -> pd.DataFrame:
+    """
+    Analyzes the class balance for classification targets.
+
+    Handles two cases:
+    1. Single Column (Binary/Multi-class): Calculates frequency of each unique value.
+    2. List of Columns (Multi-label Binary): Calculates the frequency of positive values (1) per column.
+
+    Args:
+        df (pd.DataFrame): The input DataFrame.
+        target (str | list[str]): The target column name (for single/multi-class classification) 
+                                  or list of column names (for multi-label-binary classification).
+        plot_to_dir (str | Path | None): Directory to save the balance plot.
+        plot_filename (str): Filename for the plot (without extension).
+
+    Returns:
+        pd.DataFrame: Summary table of counts and percentages.
+    """
+    # Early fail for empty DataFrame and handle list of targets with only one item
+    if df.empty:
+        _LOGGER.error("Input DataFrame is empty.")
+        raise ValueError()
+    
+    if isinstance(target, list):
+        if len(target) == 0:
+            _LOGGER.error("Target list is empty.")
+            raise ValueError()
+        elif len(target) == 1:
+            target = target[0]  # Simplify to single column case
+
+    # Case 1: Single Target (Binary or Multi-class)
+    if isinstance(target, str):
+        if target not in df.columns:
+            _LOGGER.error(f"Target column '{target}' not found in DataFrame.")
+            raise ValueError()
+        
+        # Calculate stats
+        counts = df[target].value_counts(dropna=False).sort_index()
+        percents = df[target].value_counts(normalize=True, dropna=False).sort_index() * 100
+        
+        summary = pd.DataFrame({
+            'Count': counts,
+            'Percentage': percents.round(2)
+        })
+        summary.index.name = "Class"
+        
+        # Plotting
+        if plot_to_dir:
+            try:
+                save_path = make_fullpath(plot_to_dir, make=True, enforce="directory")
+                
+                plt.figure(figsize=(10, 6))
+                # Convert index to str to handle numeric classes cleanly on x-axis
+                x_labels = summary.index.astype(str)
+                bars = plt.bar(x_labels, summary['Count'], color='lightgreen', edgecolor='black', alpha=0.7)
+                
+                plt.title(f"Class Balance: {target}")
+                plt.xlabel(target)
+                plt.ylabel("Count")
+                plt.grid(axis='y', linestyle='--', alpha=0.5)
+                
+                # Add percentage labels on top of bars
+                for bar, pct in zip(bars, summary['Percentage']):
+                    height = bar.get_height()
+                    plt.text(bar.get_x() + bar.get_width()/2, height, 
+                             f'{pct:.1f}%', ha='center', va='bottom', fontsize=10)
+                
+                plt.tight_layout()
+                full_filename = sanitize_filename(plot_filename) + ".svg"
+                plt.savefig(save_path / full_filename, format='svg', bbox_inches="tight")
+                plt.close()
+                _LOGGER.info(f"Saved class balance plot: '{full_filename}'")
+            except Exception as e:
+                _LOGGER.error(f"Failed to plot class balance. Error: {e}")
+                plt.close()
+
+        return summary
+
+    # Case 2: Multi-label (List of binary columns)
+    elif isinstance(target, list):
+        missing_cols = [t for t in target if t not in df.columns]
+        if missing_cols:
+            _LOGGER.error(f"Target columns not found: {missing_cols}")
+            raise ValueError()
+        
+        stats = []
+        for col in target:
+            # Assume 0/1 or False/True. Sum gives the count of positives.
+            # We enforce numeric to be safe
+            try:
+                numeric_series = pd.to_numeric(df[col], errors='coerce').fillna(0)
+                pos_count = numeric_series.sum()
+                total_count = len(df)
+                pct = (pos_count / total_count) * 100
+            except Exception:
+                _LOGGER.warning(f"Column '{col}' could not be processed as numeric. Assuming 0 positives.")
+                pos_count = 0
+                pct = 0.0
+
+            stats.append({
+                'Label': col,
+                'Positive_Count': int(pos_count),
+                'Positive_Percentage': round(pct, 2)
+            })
+            
+        summary = pd.DataFrame(stats).set_index("Label").sort_values("Positive_Percentage", ascending=True)
+        
+        # Plotting
+        if plot_to_dir:
+            try:
+                save_path = make_fullpath(plot_to_dir, make=True, enforce="directory")
+                
+                # Dynamic height for many labels
+                height = max(6, len(target) * 0.4)
+                plt.figure(figsize=(10, height))
+                
+                bars = plt.barh(summary.index, summary['Positive_Percentage'], color='lightgreen', edgecolor='black', alpha=0.7)
+                
+                plt.title(f"Multi-label Binary Class Balance")
+                plt.xlabel("Positive Class Percentage (%)")
+                plt.xlim(0, 100)
+                plt.grid(axis='x', linestyle='--', alpha=0.5)
+                
+                # Add count labels at the end of bars
+                for bar, count in zip(bars, summary['Positive_Count']):
+                    width = bar.get_width()
+                    plt.text(width + 1, bar.get_y() + bar.get_height()/2, f'{width:.1f}%', ha='left', va='center', fontsize=9)
+                
+                plt.tight_layout()
+                full_filename = sanitize_filename(plot_filename) + ".svg"
+                plt.savefig(save_path / full_filename, format='svg', bbox_inches="tight")
+                plt.close()
+                _LOGGER.info(f"Saved multi-label balance plot: '{full_filename}'")
+            except Exception as e:
+                _LOGGER.error(f"Failed to plot class balance. Error: {e}")
+                plt.close()
+
+        return summary.sort_values("Positive_Percentage", ascending=False)
+    
+    else:
+        _LOGGER.error("Target must be a string or a list of strings.")
+        raise TypeError()

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0}/ml_tools/data_exploration/_features.py

@@ -3,7 +3,10 @@ from pandas.api.types import is_numeric_dtype, is_object_dtype
 import numpy as np
 from typing import Any, Optional, Union
 import re
+import json
+from pathlib import Path
 
+from ..path_manager import make_fullpath
 from .._core import get_logger
 
 
@@ -15,6 +18,7 @@ __all__ = [
     "split_continuous_binary",
     "split_continuous_categorical_targets",
     "encode_categorical_features",
+    "encode_classification_target",
     "reconstruct_one_hot",
     "reconstruct_binary",
     "reconstruct_multibinary",
@@ -263,6 +267,78 @@ def encode_categorical_features(
     return df_encoded, mappings
 
 
+def encode_classification_target(
+    df: pd.DataFrame,
+    target_col: str,
+    save_dir: Union[str, Path],
+    verbose: int = 2
+) -> tuple[pd.DataFrame, dict[str, int]]:
+    """
+    Encodes a target classification column into integers (0, 1, 2...) and saves the mapping to a JSON file.
+
+    This ensures that the target variable is in the correct numeric format for training
+    and provides a persistent artifact (the JSON file) to map predictions back to labels later.
+
+    Args:
+        df (pd.DataFrame): Input DataFrame.
+        target_col (str): Name of the target column to encode.
+        save_dir (str | Path): Directory where the class map JSON will be saved.
+        verbose (int): Verbosity level for logging.
+
+    Returns:
+        Tuple (Dataframe, Dict):
+            - A new DataFrame with the target column encoded as integers.
+            - The dictionary mapping original labels (str) to integers (int).
+    """
+    if target_col not in df.columns:
+        _LOGGER.error(f"Target column '{target_col}' not found in DataFrame.")
+        raise ValueError()
+    
+    # Validation: Check for missing values in target
+    if df[target_col].isnull().any():
+        n_missing = df[target_col].isnull().sum()
+        _LOGGER.error(f"Target column '{target_col}' contains {n_missing} missing values. Please handle them before encoding.")
+        raise ValueError()
+    
+    # Ensure directory exists
+    save_path = make_fullpath(save_dir, make=True, enforce="directory")
+    file_path = save_path / "class_map.json"
+
+    # Get unique values and sort them to ensure deterministic encoding (0, 1, 2...)
+    # Convert to string to ensure the keys in JSON are strings
+    unique_labels = sorted(df[target_col].astype(str).unique())
+    
+    # Create mapping: { Label -> Integer }
+    class_map = {label: idx for idx, label in enumerate(unique_labels)}
+    
+    # Apply mapping
+    # cast column to string to match the keys in class_map
+    df_encoded = df.copy()
+    df_encoded[target_col] = df_encoded[target_col].astype(str).map(class_map)
+    
+    # Save to JSON
+    try:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(class_map, f, indent=4)
+            
+        if verbose >= 2:
+            _LOGGER.info(f"Class mapping saved to: '{file_path}'")
+        
+        if verbose >= 3:
+            _LOGGER.info(f"Target '{target_col}' encoded with {len(class_map)} classes.")
+            # Print a preview
+            if len(class_map) <= 10:
+                print(f"  Mapping: {class_map}")
+            else:
+                print(f"  Mapping (first 5): {dict(list(class_map.items())[:5])} ...")
+    
+    except Exception as e:
+        _LOGGER.error(f"Failed to save class map JSON. Error: {e}")
+        raise IOError()
+
+    return df_encoded, class_map
+
+
 def reconstruct_one_hot(
     df: pd.DataFrame,
     features_to_reconstruct: list[Union[str, tuple[str, Optional[str]]]],

{dragon_ml_toolbox-20.7.1 → dragon_ml_toolbox-20.8.0}/ml_tools/keys/_keys.py

@@ -306,6 +306,7 @@ class _EvaluationConfig:
     LOSS_PLOT_LEGEND_SIZE = 24
     # CM settings
     CM_SIZE = (9, 8)    # used for multi label binary classification confusion matrix 
+    NAME_LIMIT = 20  # max number of characters for feature/label names in plots
 
 class _OneHotOtherPlaceholder:
     """Used internally by GUI_tools."""

dragon_ml_toolbox-20.8.0/ml_tools/resampling/__init__.py

@@ -0,0 +1,19 @@
+from ._single_resampling import (
+    DragonResampler,
+)
+
+from ._multi_resampling import (
+    DragonMultiResampler,
+)
+
+from .._core import _imprimir_disponibles
+
+
+__all__ = [
+    "DragonResampler",
+    "DragonMultiResampler",
+]
+
+
+def info():
+    _imprimir_disponibles(__all__)

dragon_ml_toolbox-20.8.0/ml_tools/resampling/_base_resampler.py

@@ -0,0 +1,49 @@
+import polars as pl
+import pandas as pd
+from typing import Union
+from abc import ABC, abstractmethod
+
+
+__all__ = ["_DragonBaseResampler"]
+
+
+class _DragonBaseResampler(ABC):
+    """
+    Base class for Dragon resamplers handling common I/O and state.
+    """
+    def __init__(self, 
+                 return_pandas: bool = False, 
+                 seed: int = 42):
+        self.return_pandas = return_pandas
+        self.seed = seed
+
+    def _convert_to_polars(self, df: Union[pd.DataFrame, pl.DataFrame]) -> pl.DataFrame:
+        """Standardizes input to Polars DataFrame."""
+        if isinstance(df, pd.DataFrame):
+            return pl.from_pandas(df)
+        return df
+    
+    def _convert_to_pandas(self, df: pl.DataFrame) -> pd.DataFrame:
+        """Converts Polars DataFrame back to Pandas."""
+        return df.to_pandas(use_pyarrow_extension_array=False)
+
+    def _process_return(self, df: pl.DataFrame, shuffle: bool = True) -> Union[pd.DataFrame, pl.DataFrame]:
+        """
+        Finalizes the DataFrame:
+        1. Global Shuffle (optional but recommended for ML).
+        2. Conversion to Pandas (if requested).
+        """
+        if shuffle:
+            # Random shuffle of the final dataset
+            df = df.sample(fraction=1.0, seed=self.seed, with_replacement=False)
+        
+        if self.return_pandas:
+            return self._convert_to_pandas(df)
+        return df
+    
+    @abstractmethod
+    def describe_balance(self, df: Union[pd.DataFrame, pl.DataFrame], top_n: int = 10) -> None:
+        """
+        Prints a statistical summary of the target distribution.
+        """
+        pass