scitex 2.0.0__py2.py3-none-any.whl

scitex/ai/plt/aucs/roc_auc.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+
+import warnings
+from itertools import cycle
+
+import numpy as np
+from sklearn.metrics import roc_auc_score, roc_curve
+import pandas as pd
+
+import scitex
+
+
+def interpolate_roc_data_points(df):
+    df_new = pd.DataFrame(
+        {
+            "x": np.arange(1001) / 1000,
+            "y": np.nan,
+            "threshold": np.nan,
+        }
+    )
+
+    for i_row in range(len(df) - 1):
+        x_pre = df.iloc[i_row]["fpr"]
+        x_post = df.iloc[i_row + 1]["fpr"]
+
+        indi = (x_pre <= df_new["x"]) * (df_new["x"] <= x_post)
+
+        y_pre = df.iloc[i_row]["tpr"]
+        y_post = df.iloc[i_row + 1]["tpr"]
+
+        t_pre = df.iloc[i_row]["threshold"]
+        t_post = df.iloc[i_row + 1]["threshold"]
+
+        df_new["y"][indi] = y_pre
+        df_new["threshold"][indi] = t_pre
+
+    df_new["y"].iloc[0] = df["tpr"].iloc[0]
+    df_new["y"].iloc[-1] = df["tpr"].iloc[-1]
+
+    df_new["threshold"].iloc[0] = df["threshold"].iloc[0]
+    df_new["threshold"].iloc[-1] = df["threshold"].iloc[-1]
+
+    df_new["roc_auc"] = df["roc_auc"].iloc[0]
+
+    # import ipdb; ipdb.set_trace()
+    # assert df_new["y"].isna().sum() == 0
+    return df_new
+
+
+def to_onehot(labels, n_classes):
+    eye = np.eye(n_classes, dtype=int)
+    return eye[labels]
+
+
+def roc_auc(plt, true_class, pred_proba, labels, sdir_for_csv=None):
+    """
+    Calculates ROC-AUC curve.
+    Return: fig, metrics (dict)
+    """
+
+    # Use label_binarize to be multi-label like settings
+    n_classes = len(labels)
+    true_class_onehot = to_onehot(true_class, 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)
+
+    if sdir_for_csv is not None:
+        # to dfs
+        for i in range(n_classes):
+            class_name = labels[i].replace(" ", "_")
+            df = pd.DataFrame(
+                data={
+                    "fpr": fpr[i],
+                    "tpr": tpr[i],
+                    "threshold": threshold[i],
+                    "roc_auc": [roc_auc[i] for _ in range(len(fpr[i]))],
+                },
+                index=pd.Index(data=np.arange(len(fpr[i])), name=class_name),
+            )
+            df = interpolate_roc_data_points(df)
+            spath = f"{sdir_for_csv}{class_name}.csv"
+            scitex.io.save(df, spath)
+
+    # Plot FPR-TPR curve for each class and iso-f1 curves
+    colors = cycle(["navy", "turquoise", "darkorange", "cornflowerblue", "teal"])
+
+    fig, ax = plt.subplots()
+    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, color in zip(range(n_classes), colors):
+        (l,) = plt.plot(fpr[i], tpr[i], color=color, 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)
+
+    # return fig, roc_auc, fpr, tpr, threshold
+    return fig, metrics
+
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from scipy.special import softmax
+    from sklearn import datasets, svm
+    from sklearn.model_selection import train_test_split
+
+    def mk_demo_data(n_classes=2, batch_size=16):
+        labels = ["cls{}".format(i_cls) for i_cls in range(n_classes)]
+        true_class = np.random.randint(0, n_classes, size=(batch_size,))
+        pred_proba = softmax(np.random.rand(batch_size, n_classes), axis=-1)
+        pred_class = np.argmax(pred_proba, axis=-1)
+        return labels, true_class, pred_proba, pred_class
+
+    ## Fix seed
+    np.random.seed(42)
+
+    """
+    ################################################################################
+    ## A Minimal Example
+    ################################################################################    
+    labels, true_class, pred_proba, pred_class = \
+        mk_demo_data(n_classes=10, batch_size=256)
+
+    roc_auc, fpr, tpr, threshold = \
+        calc_roc_auc(true_class, pred_proba, labels, plot=False)
+    """
+
+    ################################################################################
+    ## MNIST
+    ################################################################################
+    from sklearn import datasets, metrics, svm
+    from sklearn.model_selection import train_test_split
+
+    digits = datasets.load_digits()
+
+    # flatten the images
+    n_samples = len(digits.images)
+    data = digits.images.reshape((n_samples, -1))
+
+    # Create a classifier: a support vector classifier
+    clf = svm.SVC(gamma=0.001, probability=True)
+
+    # Split data into 50% train and 50% test subsets
+    X_train, X_test, y_train, y_test = train_test_split(
+        data, digits.target, test_size=0.5, shuffle=False
+    )
+
+    # Learn the digits on the train subset
+    clf.fit(X_train, y_train)
+
+    # Predict the value of the digit on the test subset
+    predicted_proba = clf.predict_proba(X_test)
+    predicted = clf.predict(X_test)
+
+    n_classes = len(np.unique(digits.target))
+    labels = ["Class {}".format(i) for i in range(n_classes)]
+
+    ## Configures matplotlib
+    plt.rcParams["font.size"] = 20
+    plt.rcParams["legend.fontsize"] = "xx-small"
+    plt.rcParams["figure.figsize"] = (16 * 1.2, 9 * 1.2)
+
+    np.unique(y_test)
+    np.unique(predicted_proba)
+
+    y_test[y_test == 9] = 8  # override 9 as 8
+    ## Main
+    fig, metrics_dict = roc_auc(
+        plt, y_test, predicted_proba, labels, sdir_for_csv="./tmp/roc_test/"
+    )
+
+    fig.show()
+
+    print(metrics_dict.keys())
+    # dict_keys(['roc_auc', 'fpr', 'tpr', 'threshold'])

scitex/ai/sampling/undersample.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-24 10:13:17 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/sampling/undersample.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/sampling/undersample.py"
+
+from typing import Tuple
+from ...types import ArrayLike
+from imblearn.under_sampling import RandomUnderSampler
+
+
+def undersample(
+    X: ArrayLike, y: ArrayLike, random_state: int = 42
+) -> Tuple[ArrayLike, ArrayLike]:
+    """Undersample data preserving input type.
+
+    Args:
+        X: Features array-like of shape (n_samples, n_features)
+        y: Labels array-like of shape (n_samples,)
+    Returns:
+        Resampled X, y of same type as input
+    """
+    rus = RandomUnderSampler(random_state=random_state)
+    X_resampled, y_resampled = rus.fit_resample(X, y)
+    return X_resampled, y_resampled
+
+
+# EOF

scitex/ai/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/ai/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/ai/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/ai/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/ai/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/ai/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/__init__.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+"""Training utilities."""
+
+from .early_stopping import EarlyStopping
+from .learning_curve_logger import LearningCurveLogger
+
+__all__ = ["EarlyStopping", "LearningCurveLogger"]