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

scitex/ml/plt/_plot_roc_curve.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-02 19:44:13 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/ml/plt/plot_roc_curve.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import argparse
+
+import numpy as np
+import scitex
+from scitex.plt.color import get_colors_from_conf_matap
+from sklearn.metrics import roc_auc_score, roc_curve
+
+
+def _to_onehot(class_indices, n_classes):
+    """Convert class indices to one-hot encoding."""
+    eye = np.eye(n_classes, dtype=int)
+    return eye[class_indices]
+
+
+def plot_roc_curve(true_class, pred_proba, labels, ax=None, spath=None):
+    """
+    Plot ROC-AUC curve.
+
+    Parameters
+    ----------
+    true_class : array-like
+        True class labels
+    pred_proba : array-like
+        Predicted probabilities
+    labels : list
+        Class labels
+    ax : matplotlib axis, optional
+        Axis to plot on. If None, creates new figure
+    spath : str, optional
+        Path to save figure
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+        Figure object
+    metrics : dict
+        ROC metrics
+    """
+    import scitex as stx
+
+    # Use label_binarize to be multi-label like settings
+    n_classes = len(labels)
+
+    # Handle 1D pred_proba (binary classification with only positive class probabilities)
+    if pred_proba.ndim == 1:
+        # Convert to 2D: [P(class=0), P(class=1)]
+        pred_proba = np.column_stack([1 - pred_proba, pred_proba])
+
+    # Convert string labels to integer indices if needed
+    if true_class.dtype.kind in ('U', 'S', 'O'):  # Unicode, bytes, or object (string)
+        label_to_idx = {label: idx for idx, label in enumerate(labels)}
+        true_class_idx = np.array([label_to_idx[tc] for tc in true_class])
+    else:
+        true_class_idx = true_class
+
+    true_class_onehot = _to_onehot(true_class_idx, n_classes)
+
+    # For each class
+    fpr = dict()
+    tpr = dict()
+    threshold = dict()
+    roc_auc = dict()
+    for i in range(n_classes):
+        true_class_i_onehot = true_class_onehot[:, i]
+        pred_proba_i = pred_proba[:, i]
+
+        try:
+            fpr[i], tpr[i], threshold[i] = roc_curve(
+                true_class_i_onehot, pred_proba_i
+            )
+            roc_auc[i] = roc_auc_score(true_class_i_onehot, pred_proba_i)
+        except Exception as e:
+            print(e)
+            fpr[i], tpr[i], threshold[i], roc_auc[i] = (
+                [np.nan],
+                [np.nan],
+                [np.nan],
+                np.nan,
+            )
+
+    ## Average fpr: micro and macro
+
+    # A "micro-average": quantifying score on all classes jointly
+    fpr["micro"], tpr["micro"], threshold["micro"] = roc_curve(
+        true_class_onehot.ravel(), pred_proba.ravel()
+    )
+    roc_auc["micro"] = roc_auc_score(
+        true_class_onehot, pred_proba, average="micro"
+    )
+
+    # macro
+    _roc_aucs = []
+    for i in range(n_classes):
+        try:
+            _roc_aucs.append(
+                roc_auc_score(
+                    true_class_onehot[:, i], pred_proba[:, i], average="macro"
+                )
+            )
+        except Exception as e:
+            print(
+                f'\nROC-AUC for "{labels[i]}" was not defined and NaN-filled '
+                "for a calculation purpose (for the macro avg.)\n"
+            )
+            _roc_aucs.append(np.nan)
+    roc_auc["macro"] = np.nanmean(_roc_aucs)
+
+    # Plot FPR-TPR curve for each class and iso-f1 curves
+    # Use scitex color palette for consistent styling
+    colors = get_colors_from_conf_matap("tab10", n_classes)
+
+    if ax is None:
+        fig, ax = stx.plt.subplots()
+    else:
+        fig = ax.get_figure()
+    ax.set_box_aspect(1)
+    lines = []
+    legends = []
+
+    ## Chance Level (the diagonal line)
+    (l,) = ax.plot(
+        np.linspace(0.01, 1),
+        np.linspace(0.01, 1),
+        color="gray",
+        lw=2,
+        linestyle="--",
+        alpha=0.8,
+    )
+    lines.append(l)
+    legends.append("Chance")
+
+    ## Each Class
+    for i in range(n_classes):
+        (l,) = ax.plot(fpr[i], tpr[i], color=colors[i], lw=2)
+        lines.append(l)
+        legends.append("{0} (AUC = {1:0.2f})" "".format(labels[i], roc_auc[i]))
+
+    # fig = plt.gcf()
+    fig.subplots_adjust(bottom=0.25)
+    ax.set_xlim([-0.01, 1.01])
+    ax.set_ylim([-0.01, 1.01])
+    ax.set_xticks([0.0, 0.5, 1.0])
+    ax.set_yticks([0.0, 0.5, 1.0])
+    ax.set_xlabel("FPR")
+    ax.set_ylabel("TPR")
+    ax.set_title("ROC Curve")
+    ax.legend(lines, legends, loc="lower right")
+
+    metrics = dict(roc_auc=roc_auc, fpr=fpr, tpr=tpr, threshold=threshold)
+
+    # Save figure if spath is provided
+    if spath is not None:
+        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, metrics
+
+
+def main(args):
+    """Demo ROC AUC plotting with MNIST dataset."""
+    import matplotlib.pyplot as plt
+    from sklearn import datasets, svm
+    from sklearn.model_selection import train_test_split
+
+    np.random.seed(42)
+
+    digits = datasets.load_digits()
+    n_samples = len(digits.images)
+    data = digits.images.reshape((n_samples, -1))
+
+    clf = svm.SVC(gamma=0.001, probability=True)
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        data, digits.target, test_size=0.5, shuffle=False
+    )
+
+    clf.fit(X_train, y_train)
+    predicted_proba = clf.predict_proba(X_test)
+
+    n_classes = len(np.unique(digits.target))
+    labels = ["Class {}".format(i) for i in range(n_classes)]
+
+    # plt.rcParams["font.size"] = 20
+    # plt.rcParams["legend.fontsize"] = "xx-small"
+    # plt.rcParams["figure.figsize"] = (16 * 1.2, 9 * 1.2)
+
+    y_test[y_test == 9] = 8  # override 9 as 8
+
+    fig, metrics_dict = plot_roc_curve(
+        true_class=y_test, pred_proba=predicted_proba, labels=labels
+    )
+
+    scitex.io.save(fig, "plot_roc_curve_demo.jpg")
+    return 0
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Demo ROC AUC 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()
+
+
+# Backward compatibility alias
+roc_auc = plot_roc_curve
+
+# EOF

scitex/ml/sk/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""Scitex sk module."""
+
+from ._clf import GB_pipeline, rocket_pipeline
+from ._to_sktime import to_sktime_df
+
+__all__ = [
+    "GB_pipeline",
+    "rocket_pipeline",
+    "to_sktime_df",
+]

scitex/ml/sk/_clf.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-03-23 17:36:05 (ywatanabe)"
+
+import numpy as np
+from sklearn.decomposition import PCA
+from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
+from sklearn.feature_selection import SelectKBest, f_classif
+from sklearn.linear_model import LogisticRegression, RidgeClassifierCV
+from sklearn.pipeline import make_pipeline
+from sklearn.svm import SVC, LinearSVC
+from sktime.classification.deep_learning.cnn import CNNClassifier
+from sktime.classification.deep_learning.inceptiontime import (
+    InceptionTimeClassifier,
+)
+from sktime.classification.deep_learning.lstmfcn import LSTMFCNClassifier
+from sktime.classification.dummy import DummyClassifier
+from sktime.classification.feature_based import TSFreshClassifier
+from sktime.classification.hybrid import HIVECOTEV2
+from sktime.classification.interval_based import TimeSeriesForestClassifier
+from sktime.classification.kernel_based import RocketClassifier, TimeSeriesSVC
+from sktime.transformations.panel.reduce import Tabularizer
+from sktime.transformations.panel.rocket import Rocket
+
+# _rocket_pipeline = make_pipeline(
+#     Rocket(n_jobs=-1),
+#     RidgeClassifierCV(alphas=np.logspace(-3, 3, 10)),
+# )
+
+
+# def rocket_pipeline(*args, **kwargs):
+#     return _rocket_pipeline
+
+
+def rocket_pipeline(*args, **kwargs):
+    return make_pipeline(
+        Rocket(*args, **kwargs),
+        LogisticRegression(
+            max_iter=1000
+        ),  # Increase max_iter if needed for convergence
+        # RidgeClassifierCV(alphas=np.logspace(-3, 3, 10)),
+        # SVC(probability=True, kernel="linear"),
+    )
+
+
+# def rocket_pipeline(*args, **kwargs):
+#     return make_pipeline(
+#         Rocket(*args, **kwargs),
+#         SelectKBest(f_classif, k=500),
+#         PCA(n_components=100),
+#         LinearSVC(dual=False, tol=1e-3, C=0.1, probability=True),
+#     )
+
+
+GB_pipeline = make_pipeline(
+    Tabularizer(),
+    GradientBoostingClassifier(),
+)

scitex/ml/sk/_to_sktime.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-03-05 13:17:04 (ywatanabe)"
+
+# import warnings
+
+import numpy as np
+import pandas as pd
+import torch
+
+
+def to_sktime_df(X):
+    """
+    Converts a dataset to a format compatible with sktime, encapsulating each sample as a pandas DataFrame.
+
+    Arguments:
+    - X (numpy.ndarray or torch.Tensor or pandas.DataFrame): The input dataset with shape (n_samples, n_chs, seq_len).
+      It should be a 3D array-like structure containing the time series data.
+
+    Return:
+    - sktime_df (pandas.DataFrame): A DataFrame where each element is a pandas Series representing a univariate time series.
+
+    Data Types and Shapes:
+    - If X is a numpy.ndarray, it should have the shape (n_samples, n_chs, seq_len).
+    - If X is a torch.Tensor, it should have the shape (n_samples, n_chs, seq_len) and will be converted to a numpy array.
+    - If X is a pandas.DataFrame, it is assumed to already be in the correct format and will be returned as is.
+
+    References:
+    - sktime: https://github.com/alan-turing-institute/sktime
+
+    Examples:
+    --------
+    >>> X_np = np.random.rand(64, 160, 1024)
+    >>> sktime_df = to_sktime_df(X_np)
+    >>> type(sktime_df)
+    <class 'pandas.core.frame.DataFrame'>
+    """
+    if isinstance(X, pd.DataFrame):
+        return X
+    elif torch.is_tensor(X):
+        X = X.numpy()
+    elif not isinstance(X, np.ndarray):
+        raise ValueError(
+            "Input X must be a numpy.ndarray, torch.Tensor, or pandas.DataFrame"
+        )
+
+    X = X.astype(np.float64)
+
+    def _format_a_sample_for_sktime(x):
+        """
+        Formats a single sample for sktime compatibility.
+
+        Arguments:
+        - x (numpy.ndarray): A 2D array with shape (n_chs, seq_len) representing a single sample.
+
+        Return:
+        - dims (pandas.Series): A Series where each element is a pandas Series representing a univariate time series.
+        """
+        return pd.Series([pd.Series(x[d], name=f"dim_{d}") for d in range(x.shape[0])])
+
+    sktime_df = pd.DataFrame(
+        [_format_a_sample_for_sktime(X[i]) for i in range(X.shape[0])]
+    )
+    return sktime_df
+
+
+# # Obsolete warning for future compatibility
+# def to_sktime(*args, **kwargs):
+#     warnings.warn(
+#         "to_sktime is deprecated; use to_sktime_df instead.", FutureWarning
+#     )
+#     return to_sktime_df(*args, **kwargs)
+
+
+# import pandas as pd
+# import numpy as np
+# import torch
+
+# def to_sktime(X):
+#     """
+#     X.shape: (n_samples, n_chs, seq_len)
+#     """
+
+#     def _format_a_sample_for_sktime(x):
+#         """
+#         x.shape: (n_chs, seq_len)
+#         """
+#         dims = pd.Series(
+#             [pd.Series(x[d], name=f"dim_{d}") for d in range(len(x))],
+#             index=[f"dim_{i}" for i in np.arange(len(x))],
+#         )
+#         return dims
+
+#     if torch.is_tensor(X):
+#         X = X.numpy()
+#         X = X.astype(np.float64)
+
+#     return pd.DataFrame(
+#         [_format_a_sample_for_sktime(X[i]) for i in range(len(X))]
+#     )

scitex/ml/sklearn/__init__.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""Sklearn wrappers and utilities."""
+
+import warnings
+
+try:
+    from .clf import *
+except ImportError as e:
+    warnings.warn(
+        f"Could not import clf from scitex.ai.sklearn: {str(e)}. "
+        f"Some functionality may be unavailable. "
+        f"Consider installing missing dependencies if you need this module.",
+        ImportWarning,
+        stacklevel=2
+    )
+
+try:
+    from .to_sktime import *
+except ImportError as e:
+    warnings.warn(
+        f"Could not import to_sktime from scitex.ai.sklearn: {str(e)}. "
+        f"Some functionality may be unavailable. "
+        f"Consider installing missing dependencies if you need this module.",
+        ImportWarning,
+        stacklevel=2
+    )

scitex/ml/sklearn/clf.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-03-23 17:36:05 (ywatanabe)"
+
+import numpy as np
+from sklearn.decomposition import PCA
+from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
+from sklearn.feature_selection import SelectKBest, f_classif
+from sklearn.linear_model import LogisticRegression, RidgeClassifierCV
+from sklearn.pipeline import make_pipeline
+from sklearn.svm import SVC, LinearSVC
+from sktime.classification.deep_learning.cnn import CNNClassifier
+from sktime.classification.deep_learning.inceptiontime import (
+    InceptionTimeClassifier,
+)
+from sktime.classification.deep_learning.lstmfcn import LSTMFCNClassifier
+from sktime.classification.dummy import DummyClassifier
+from sktime.classification.feature_based import TSFreshClassifier
+from sktime.classification.hybrid import HIVECOTEV2
+from sktime.classification.interval_based import TimeSeriesForestClassifier
+from sktime.classification.kernel_based import RocketClassifier, TimeSeriesSVC
+from sktime.transformations.panel.reduce import Tabularizer
+from sktime.transformations.panel.rocket import Rocket
+
+# _rocket_pipeline = make_pipeline(
+#     Rocket(n_jobs=-1),
+#     RidgeClassifierCV(alphas=np.logspace(-3, 3, 10)),
+# )
+
+
+# def rocket_pipeline(*args, **kwargs):
+#     return _rocket_pipeline
+
+
+def rocket_pipeline(*args, **kwargs):
+    return make_pipeline(
+        Rocket(*args, **kwargs),
+        LogisticRegression(
+            max_iter=1000
+        ),  # Increase max_iter if needed for convergence
+        # RidgeClassifierCV(alphas=np.logspace(-3, 3, 10)),
+        # SVC(probability=True, kernel="linear"),
+    )
+
+
+# def rocket_pipeline(*args, **kwargs):
+#     return make_pipeline(
+#         Rocket(*args, **kwargs),
+#         SelectKBest(f_classif, k=500),
+#         PCA(n_components=100),
+#         LinearSVC(dual=False, tol=1e-3, C=0.1, probability=True),
+#     )
+
+
+GB_pipeline = make_pipeline(
+    Tabularizer(),
+    GradientBoostingClassifier(),
+)

scitex/ml/sklearn/to_sktime.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-03-05 13:17:04 (ywatanabe)"
+
+# import warnings
+
+import numpy as np
+import pandas as pd
+import torch
+
+
+def to_sktime_df(X):
+    """
+    Converts a dataset to a format compatible with sktime, encapsulating each sample as a pandas DataFrame.
+
+    Arguments:
+    - X (numpy.ndarray or torch.Tensor or pandas.DataFrame): The input dataset with shape (n_samples, n_chs, seq_len).
+      It should be a 3D array-like structure containing the time series data.
+
+    Return:
+    - sktime_df (pandas.DataFrame): A DataFrame where each element is a pandas Series representing a univariate time series.
+
+    Data Types and Shapes:
+    - If X is a numpy.ndarray, it should have the shape (n_samples, n_chs, seq_len).
+    - If X is a torch.Tensor, it should have the shape (n_samples, n_chs, seq_len) and will be converted to a numpy array.
+    - If X is a pandas.DataFrame, it is assumed to already be in the correct format and will be returned as is.
+
+    References:
+    - sktime: https://github.com/alan-turing-institute/sktime
+
+    Examples:
+    --------
+    >>> X_np = np.random.rand(64, 160, 1024)
+    >>> sktime_df = to_sktime_df(X_np)
+    >>> type(sktime_df)
+    <class 'pandas.core.frame.DataFrame'>
+    """
+    if isinstance(X, pd.DataFrame):
+        return X
+    elif torch.is_tensor(X):
+        X = X.detach().numpy()
+    elif not isinstance(X, np.ndarray):
+        raise ValueError(
+            "Input X must be a numpy.ndarray, torch.Tensor, or pandas.DataFrame"
+        )
+
+    X = X.astype(np.float64)
+
+    def _format_a_sample_for_sktime(x):
+        """
+        Formats a single sample for sktime compatibility.
+
+        Arguments:
+        - x (numpy.ndarray): A 2D array with shape (n_chs, seq_len) representing a single sample.
+
+        Return:
+        - dims (pandas.Series): A Series where each element is a pandas Series representing a univariate time series.
+        """
+        return pd.Series([pd.Series(x[d], name=f"dim_{d}") for d in range(x.shape[0])])
+
+    sktime_df = pd.DataFrame(
+        [_format_a_sample_for_sktime(X[i]) for i in range(X.shape[0])]
+    )
+    return sktime_df
+
+
+# # Obsolete warning for future compatibility
+# def to_sktime(*args, **kwargs):
+#     warnings.warn(
+#         "to_sktime is deprecated; use to_sktime_df instead.", FutureWarning
+#     )
+#     return to_sktime_df(*args, **kwargs)
+
+
+# import pandas as pd
+# import numpy as np
+# import torch
+
+# def to_sktime(X):
+#     """
+#     X.shape: (n_samples, n_chs, seq_len)
+#     """
+
+#     def _format_a_sample_for_sktime(x):
+#         """
+#         x.shape: (n_chs, seq_len)
+#         """
+#         dims = pd.Series(
+#             [pd.Series(x[d], name=f"dim_{d}") for d in range(len(x))],
+#             index=[f"dim_{i}" for i in np.arange(len(x))],
+#         )
+#         return dims
+
+#     if torch.is_tensor(X):
+#         X = X.numpy()
+#         X = X.astype(np.float64)
+
+#     return pd.DataFrame(
+#         [_format_a_sample_for_sktime(X[i]) for i in range(len(X))]
+#     )

scitex/{ai/training/early_stopping.py → ml/training/_EarlyStopping.py}

@@ -60,9 +60,8 @@ class EarlyStopping:
                 )
             if self.counter >= self.patience:
                 if self.verbose:
-                    scitex.str.printc("Early-stopped.", c="yellow")
+                    scitex.gen.print_block("Early-stopped.", c="yellow")
                 return True
-            return False
 
     def save(self, current_score, models_spaths_dict, i_global):
         """Saves model when validation score decrease."""