scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/ai/plt/__init__.py

@@ -1,16 +1,52 @@
 #!/usr/bin/env python3
-"""Scitex plt module."""
+"""Scitex centralized plotting module.
 
-from ._conf_mat import calc_bACC_from_cm, calc_balanced_accuracy_from_cm, conf_mat
-from ._learning_curve import learning_curve, plot_tra, process_i_global, scatter_tes, scatter_val, select_ticks, set_yaxis_for_acc, vline_at_epochs
-from ._optuna_study import optuna_study
+Note: Metric calculation functions (calc_*) are imported from scitex.ml.metrics
+but re-exported here for backward compatibility. New code should import directly
+from scitex.ml.metrics instead.
+"""
+
+from ._plot_conf_mat import calc_bACC_from_conf_mat, calc_bacc_from_conf_mat, plot_conf_mat, conf_mat
+from ._plot_learning_curve import (
+    plot_learning_curve,
+    _prepare_metrics_df,
+    _configure_accuracy_axis,
+    _plot_training_data,
+    _plot_validation_data,
+    _plot_test_data,
+    _add_epoch_vlines,
+    _select_epoch_ticks,
+)
+from ._plot_optuna_study import optuna_study, plot_optuna_study
+from ._plot_roc_curve import plot_roc_curve
+from ._plot_pre_rec_curve import plot_pre_rec_curve
+from ._plot_feature_importance import (
+    plot_feature_importance,
+    plot_feature_importance_cv_summary,
+)
+
+# Backward compatibility aliases
+learning_curve = plot_learning_curve
+plot_tra = _plot_training_data
+process_i_global = _prepare_metrics_df
+scatter_tes = _plot_test_data
+scatter_val = _plot_validation_data
+select_ticks = _select_epoch_ticks
+set_yaxis_for_acc = _configure_accuracy_axis
+vline_at_epochs = _add_epoch_vlines
 
 __all__ = [
-    "calc_bACC_from_cm",
-    "calc_balanced_accuracy_from_cm",
-    "conf_mat",
-    "learning_curve",
+    # Plotting functions
+    "plot_conf_mat",
+    "conf_mat",  # backward compat
+    "plot_learning_curve",
+    "learning_curve",  # backward compat
     "optuna_study",
+    "plot_optuna_study",
+    "plot_roc_curve",
+    "plot_pre_rec_curve",
+    "plot_feature_importance",
+    "plot_feature_importance_cv_summary",
     "plot_tra",
     "process_i_global",
     "scatter_tes",
@@ -18,4 +54,7 @@ __all__ = [
     "select_ticks",
     "set_yaxis_for_acc",
     "vline_at_epochs",
+    # Metric calculations (re-exported from scitex.ml.metrics for backward compat)
+    "calc_bACC_from_conf_mat",
+    "calc_bacc_from_conf_mat",
 ]

scitex/ai/plt/{_conf_mat.py → _plot_conf_mat.py}

@@ -1,17 +1,34 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-02 07:15:10 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/ml/plt/plot_conf_mat.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import argparse
+
 import matplotlib
-import scitex
 import numpy as np
 import pandas as pd
+import scitex
 import seaborn as sns
 from matplotlib import ticker
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 from sklearn.metrics import balanced_accuracy_score
 from sklearn.metrics import confusion_matrix as sklearn_confusion_matrix
 
+# Import metric calculation from centralized location (SoC: metrics in scitex.ml.metrics)
+from scitex.ml.metrics import calc_bacc_from_conf_mat
 
-def conf_mat(
-    plt,
+# Aliases for backward compatibility
+calc_bACC_from_conf_mat = calc_bacc_from_conf_mat
+
+
+def plot_conf_mat(
     cm=None,
     y_true=None,
     y_pred=None,
@@ -27,6 +44,7 @@ def conf_mat(
     colorbar=True,
     x_extend_ratio=1.0,
     y_extend_ratio=1.0,
+    ax=None,
     spath=None,
 ):
     """
@@ -34,8 +52,40 @@ def conf_mat(
 
     Parameters
     ----------
-    plt : matplotlib.pyplot
-        Pyplot object for plotting
+    cm : array-like, optional
+        Pre-computed confusion matrix
+    y_true : array-like, optional
+        True labels
+    y_pred : array-like, optional
+        Predicted labels
+    y_pred_proba : array-like, optional
+        Predicted probabilities
+    labels : list, optional
+        List of labels
+    sorted_labels : list, optional
+        Sorted list of labels
+    pred_labels : list, optional
+        Predicted label names
+    sorted_pred_labels : list, optional
+        Sorted predicted label names
+    true_labels : list, optional
+        True label names
+    sorted_true_labels : list, optional
+        Sorted true label names
+    label_rotation_xy : tuple, optional
+        Rotation angles for x and y labels
+    title : str, optional
+        Title of the plot
+    colorbar : bool, optional
+        Whether to include a colorbar
+    x_extend_ratio : float, optional
+        Ratio to extend x-axis
+    y_extend_ratio : float, optional
+        Ratio to extend y-axis
+    spath : str, optional
+        Path to save the figure
+    plt : deprecated
+        Kept for backward compatibility only
     cm : array-like, optional
         Pre-computed confusion matrix
     y_true : array-like, optional
@@ -91,14 +141,16 @@ def conf_mat(
     assert (cm is not None) or ((y_true is not None) and (y_pred is not None))
 
     if cm is None:
-        with scitex.gen.suppress_output():
+        with scitex.context.suppress_output():
             cm = sklearn_confusion_matrix(y_true, y_pred, labels=labels)
 
-    bacc = calc_bACC_from_cm(cm)
+    bacc = calc_bACC_from_conf_mat(cm)
 
     title = f"{title} (bACC = {bacc:.3f})"
 
-    if labels is not None:
+    # Only reconstruct full confusion matrix if we have y_true and y_pred
+    # When cm is passed directly, use it as-is
+    if labels is not None and y_true is not None and y_pred is not None:
         full_cm = np.zeros((len(labels), len(labels)))
         unique_true = np.unique(y_true)
         unique_pred = np.unique(y_pred)
@@ -114,7 +166,7 @@ def conf_mat(
     cm = pd.DataFrame(data=cm).copy()
 
     labels_to_latex = lambda labels: (
-        [scitex.gen.to_latex_style(label) for label in labels]
+        [scitex.str.to_latex_style(label) for label in labels]
         if labels is not None
         else None
     )
@@ -137,11 +189,19 @@ def conf_mat(
         assert set(sorted_labels) == set(labels)
         cm = cm.reindex(index=sorted_labels, columns=sorted_labels)
 
-    fig, ax = plt.subplots()
+    # Use stx.plt.subplots() for CSV export functionality
+    # The AxisWrapper provides export_as_csv method for automatic data export
+    import matplotlib.pyplot as mpl_plt
+    import scitex as stx
+
+    if ax is None:
+        fig, ax = stx.plt.subplots()
+    else:
+        fig = ax.get_figure()
     res = sns.heatmap(
         cm,
         annot=True,
-        annot_kws={"size": plt.rcParams["font.size"]},
+        annot_kws={"size": mpl_plt.rcParams["font.size"]},
         fmt=".0f",
         cmap="Blues",
         cbar=False,
@@ -181,15 +241,19 @@ def conf_mat(
     dx = width_orig - width_tgt
 
     if colorbar:
-        divider = make_axes_locatable(ax)
-        cax = divider.append_axes("right", size="5%", pad=0.1)
-        cax = scitex.plt.ax.shift(cax, dx=-dx * 2.54, dy=0)
-        fig.add_axes(cax)
+        # Extract underlying matplotlib axes if wrapped by SciTeX
+        ax_mpl = ax._axis_mpl if hasattr(ax, '_axis_mpl') else ax
+
+        divider = make_axes_locatable(ax_mpl)
+        cax = divider.append_axes("right", size="5%", pad=0.15)
+
+        # Get the underlying figure
+        fig_mpl = fig._fig_mpl if hasattr(fig, '_fig_mpl') else fig
 
         vmax = np.array(cm).max().astype(int)
         norm = matplotlib.colors.Normalize(vmin=0, vmax=vmax)
-        cbar = fig.colorbar(
-            plt.cm.ScalarMappable(norm=norm, cmap="Blues"),
+        cbar = fig_mpl.colorbar(
+            matplotlib.cm.ScalarMappable(norm=norm, cmap="Blues"),
             cax=cax,
         )
         cbar.locator = ticker.MaxNLocator(nbins=4)
@@ -197,71 +261,29 @@ def conf_mat(
         cbar.outline.set_edgecolor("white")
 
     if spath is not None:
-        scitex.io.save(fig, spath)
+        from pathlib import Path
+        # Resolve to absolute path to prevent _out directory creation
+        spath_abs = Path(spath).resolve() if isinstance(spath, (str, Path)) else spath
+        scitex.io.save(fig, str(spath_abs), use_caller_path=False)
 
     return fig, cm
 
 
-def calc_bACC_from_cm(cm):
-    """
-    Calculate balanced accuracy from confusion matrix.
-
-    Parameters
-    ----------
-    cm : array-like
-        Confusion matrix
-
-    Returns
-    -------
-    float
-        Balanced accuracy
+# Backward compatibility alias
+conf_mat = plot_conf_mat
 
-    Example
-    -------
-    cm = np.array([[5, 1], [2, 3]])
-    bacc = calc_bACC_from_cm(cm)
-    print(bacc)
-    """
-    with scitex.gen.suppress_output():
-        try:
-            per_class = np.diag(cm) / np.nansum(cm, axis=1)
-            bacc = np.nanmean(per_class)
-        except:
-            bacc = np.nan
-        return round(bacc, 3)
 
+# Metric calculation functions have been moved to scitex.ml.metrics
+# They are imported above for use in this module
+# This maintains SoC: plotting in scitex.ml.plt, metrics in scitex.ml.metrics
 
-def calc_balanced_accuracy_from_cm(cm):
-    """
-    Calculate balanced accuracy from confusion matrix (snake_case alias).
-    
-    This is an alias for calc_bACC_from_cm with snake_case naming.
-    
-    Parameters
-    ----------
-    cm : array-like
-        Confusion matrix
-        
-    Returns
-    -------
-    float
-        Balanced accuracy
-    """
-    return calc_bACC_from_cm(cm)
 
-
-if __name__ == "__main__":
-    import sys
-    import matplotlib.pyplot as plt
-    import scitex
-    import numpy as np
+def main(args):
+    """Demo confusion matrix plotting with Iris dataset."""
     import sklearn
     from sklearn import datasets, svm
     from sklearn.model_selection import train_test_split
 
-    sys.path.append(".")
-    import scitex
-
     iris = datasets.load_iris()
     X = iris.data
     y = iris.target
@@ -269,15 +291,16 @@ if __name__ == "__main__":
 
     X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)
 
-    classifier = svm.SVC(kernel="linear", C=0.01, random_state=42).fit(X_train, y_train)
+    classifier = svm.SVC(kernel="linear", C=0.01, random_state=42).fit(
+        X_train, y_train
+    )
 
     y_pred = classifier.predict(X_test)
-    cm = sklearn.metrics.confusion_matrix(y_test, y_pred)
-    cm **= 3
+    cm_data = sklearn.metrics.confusion_matrix(y_test, y_pred)
+    cm_data **= 3
 
-    fig, cm = conf_mat(
-        plt,
-        cm,
+    fig, cm_result = conf_mat(
+        cm=cm_data,
         pred_labels=["A", "B", "C"],
         true_labels=["a", "b", "c"],
         label_rotation_xy=(60, 60),
@@ -291,7 +314,50 @@ if __name__ == "__main__":
         y=True,
     )
 
-    plt.show()
+    scitex.io.save(fig, "plot_conf_mat_demo.jpg")
+    return 0
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments."""
+    import argparse
+    parser = argparse.ArgumentParser(description='Demo confusion matrix plotting')
+    return parser.parse_args()
+
+
+def run_main() -> None:
+    """Initialize scitex framework, run main function, and cleanup."""
+    global CONFIG, CC, sys, plt, rng
+
+    import sys
+    import matplotlib.pyplot as plt
+    import scitex as stx
+
+    args = parse_args()
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
+        sys,
+        plt,
+        args=args,
+        file=__FILE__,
+        sdir_suffix=None,
+        verbose=False,
+        agg=True,
+    )
+
+    exit_status = main(args)
+
+    stx.session.close(
+        CONFIG,
+        verbose=False,
+        notify=False,
+        message="",
+        exit_status=exit_status,
+    )
+
+
+if __name__ == "__main__":
+    run_main()
 
 # EOF
 
@@ -353,11 +419,11 @@ if __name__ == "__main__":
 #     assert (cm is not None) or ((y_true is not None) and (y_pred is not None))
 
 #     if cm is None:
-#         with scitex.gen.suppress_output():
+#         with scitex.context.suppress_output():
 #             cm = sklearn_confusion_matrix(y_true, y_pred, labels=labels)
 #             # cm = sklearn_confusion_matrix(y_true, y_pred)
 
-#     bacc = calc_bACC_from_cm(cm)
+#     bacc = calc_bACC_from_conf_mat(cm)
 
 #     title = f"{title} (bACC = {bacc})"
 
@@ -382,13 +448,13 @@ if __name__ == "__main__":
 
 #     # To LaTeX styles
 #     if pred_labels is not None:
-#         pred_labels = [scitex.gen.to_latex_style(l) for l in pred_labels]
+#         pred_labels = [scitex.str.to_latex_style(l) for l in pred_labels]
 #     if true_labels is not None:
-#         true_labels = [scitex.gen.to_latex_style(l) for l in true_labels]
+#         true_labels = [scitex.str.to_latex_style(l) for l in true_labels]
 #     if labels is not None:
-#         labels = [scitex.gen.to_latex_style(l) for l in labels]
+#         labels = [scitex.str.to_latex_style(l) for l in labels]
 #     if sorted_labels is not None:
-#         sorted_labels = [scitex.gen.to_latex_style(l) for l in sorted_labels]
+#         sorted_labels = [scitex.str.to_latex_style(l) for l in sorted_labels]
 
 #     # Prediction Labels: columns
 #     if pred_labels is not None:
@@ -408,11 +474,14 @@ if __name__ == "__main__":
 #         cm = cm.reindex(index=sorted_labels, columns=sorted_labels)
 
 #     # Main
-#     fig, ax = plt.subplots()
+#     # Use stx.plt.subplots for advanced CSV export and SciTeX Viz integration
+    import matplotlib.pyplot as mpl_plt
+    import scitex as stx
+    fig, ax = stx.plt.subplots()
 #     res = sns.heatmap(
 #         cm,
 #         annot=True,
-#         annot_kws={"size": plt.rcParams["font.size"]},
+#         annot_kws={"size": mpl_plt.rcParams["font.size"]},
 #         fmt=".0f",
 #         cmap="Blues",
 #         cbar=False,
@@ -506,8 +575,8 @@ if __name__ == "__main__":
 #     return fig, cm
 
 
-# def calc_bACC_from_cm(cm):
-#     with scitex.gen.suppress_output():
+# def calc_bACC_from_conf_mat(cm):
+#     with scitex.context.suppress_output():
 #         try:
 #             per_class = np.diag(cm) / np.nansum(cm, axis=1)
 #             bacc = round(np.nanmean(per_class), 3)
@@ -590,3 +659,5 @@ if __name__ == "__main__":
 #     plt.show()
 
 #     ## EOF
+
+# EOF