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

scitex/ml/clustering/_umap.py

@@ -0,0 +1,376 @@
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-09-12 05:37:55 (ywatanabe)"
+# _umap_dev.py
+
+
+"""
+This script does XYZ.
+"""
+
+
+"""
+Imports
+"""
+import sys
+
+import matplotlib.pyplot as plt
+import scitex
+import numpy as np
+import umap.umap_ as umap_orig
+from natsort import natsorted
+from sklearn.preprocessing import LabelEncoder
+
+# sys.path = ["."] + sys.path
+# from scripts import utils, load
+
+"""
+Warnings
+"""
+# warnings.simplefilter("ignore", UserWarning)
+
+
+"""
+Config
+"""
+# CONFIG = scitex.gen.load_configs()
+
+
+"""
+Functions & Classes
+"""
+
+
+def umap(
+    data,
+    labels,
+    hues=None,
+    hues_colors=None,
+    axes=None,
+    axes_titles=None,
+    supervised=False,
+    title="UMAP Clustering",
+    alpha=1.0,
+    s=3,
+    use_independent_legend=False,
+    add_super_imposed=False,
+    umap_model=None,
+):
+    """
+    Perform UMAP clustering and visualization.
+
+    Parameters
+    ----------
+    data_all : list
+        List of data arrays to cluster
+    labels_all : list
+        List of label arrays corresponding to data_all
+    hues_all : list, optional
+        List of hue arrays for coloring points
+    hues_colors_all : list, optional
+        List of color mappings for hues
+    axes : matplotlib.axes.Axes, optional
+        Existing axes to plot on
+    axes_titles : list, optional
+        Titles for each subplot
+    supervised : bool, optional
+        Whether to use supervised UMAP
+    title : str, optional
+        Main title for the plot
+    alpha : float, optional
+        Transparency of points
+    s : int, optional
+        Size of points
+    use_independent_legend : bool, optional
+        Whether to create separate legend figures
+    add_super_imposed : bool, optional
+        Whether to add a superimposed plot
+    umap_model : umap.UMAP, optional
+        Pre-fitted UMAP model
+
+    Returns
+    -------
+    tuple
+        Figure, legend figures (if applicable), and UMAP model
+    """
+
+    # Renaming
+    data_all = data
+    labels_all = labels
+    hues_all = hues
+    hues_colors_all = hues_colors
+
+    data_all, labels_all, hues_all, hues_colors_all = _check_input_vars(
+        data_all, labels_all, hues_all, hues_colors_all
+    )
+
+    # Label Encoding
+    le = LabelEncoder()
+    le.fit(natsorted(np.hstack(labels_all)))
+    labels_all = [le.transform(labels) for labels in labels_all]
+
+    # Running UMAP Clustering
+    _umap = _run_umap(umap_model, data_all, labels_all, supervised, title)
+
+    # Plotting
+    fig, legend_figs = _plot(
+        _umap,
+        le,
+        data_all,
+        labels_all,
+        hues_all,
+        hues_colors_all,
+        add_super_imposed,
+        axes,
+        title,
+        axes_titles,
+        use_independent_legend,
+        s,
+        alpha,
+    )
+
+    return fig, legend_figs, _umap
+
+
+def _plot(
+    _umap,
+    le,
+    data_all,
+    labels_all,
+    hues_all,
+    hues_colors_all,
+    add_super_imposed,
+    axes,
+    title,
+    axes_titles,
+    use_independent_legend,
+    s,
+    alpha,
+):
+    # Plotting
+    ncols = len(data_all) + 1 if add_super_imposed else len(data_all)
+    share = True if ncols > 1 else False
+
+    if axes is None:
+        fig, axes = scitex.plt.subplots(ncols=ncols, sharex=share, sharey=share)
+    else:
+        assert len(axes) == ncols
+        fig = (
+            axes[0].get_figure()
+            # axes
+            if isinstance(
+                axes, (np.ndarray, scitex.plt._subplots._AxesWrapper.AxesWrapper)
+            )
+            # axis
+            else axes.get_figure()
+        )
+
+    fig.supxyt("UMAP 1", "UMAP 2", title)
+
+    for ii, (data, labels, hues, hues_colors) in enumerate(
+        zip(data_all, labels_all, hues_all, hues_colors_all)
+    ):
+        embedding = _umap.transform(data)
+
+        # ax
+        if ncols == 1:
+            ax = axes
+        else:
+            ax = axes[ii + 1] if add_super_imposed else axes[ii]
+
+        _hues = le.inverse_transform(labels) if hues is None else hues
+        for hue in np.unique(_hues):
+            indi = hue == np.array(_hues)
+
+            if hues_colors:
+                colors = np.vstack(hues_colors)[indi]
+                colors = [colors[ii] for ii in range(len(colors))]
+            else:
+                colors = None
+            ax.scatter(
+                x=embedding[:, 0][indi],
+                y=embedding[:, 1][indi],
+                label=hue,
+                c=colors,
+                s=s,
+                alpha=alpha,
+            )
+
+        ax.set_box_aspect(1)
+
+        if axes_titles is not None:
+            ax.set_title(axes_titles[ii])
+
+        # Merged axis
+        if add_super_imposed:
+            ax = axes[0]
+            _hues = le.inverse_transform(labels) if hues is None else hues
+            for hue in np.unique(_hues):
+                indi = hue == np.array(_hues)
+                ax.scatter(
+                    x=embedding[:, 0][indi],
+                    y=embedding[:, 1][indi],
+                    label=hue,
+                    c=np.vstack(hues_colors)[indi][0],
+                    s=s,
+                    alpha=alpha,
+                )
+
+            ax.set_title("Superimposed")
+            ax.set_box_aspect(1)
+            # ax.sns_scatterplot(
+            #     x=embedding[:, 0],
+            #     y=embedding[:, 1],
+            #     hue=le.inverse_transform(labels) if hues is None else hues,
+            #     palette=hues_colors,
+            #     legend="full" if ii == 0 else False,
+            #     s=s,
+            #     alpha=alpha,
+            # )
+
+    if share:
+        scitex.plt.ax.sharex(axes)
+        scitex.plt.ax.sharey(axes)
+
+    if not use_independent_legend:
+        for ax in axes.flat:
+            ax.legend(loc="upper left")
+        return fig, None
+
+    elif use_independent_legend:
+        legend_figs = []
+        for i, ax in enumerate(axes):
+            legend = ax.get_legend()
+            if legend:
+                legend_fig = plt.figure(figsize=(3, 2))
+
+                new_legend = legend_fig.gca().legend(
+                    handles=legend.get_lines(),
+                    labels=[t.get_text() for t in legend.texts],
+                    loc="center",
+                )
+
+                # new_legend = legend_fig.gca().legend(
+                #     handles=legend.legendHandles,
+                #     labels=legend.texts,
+                #     loc="center",
+                # )
+
+                # legend_fig.canvas.draw()
+                legend_figs.append(legend_fig)
+                ax.get_legend().remove()
+
+        for ax in axes:
+            ax.legend_ = None
+
+        # elif use_independent_legend:
+        #     legend_figs = []
+        #     for i, ax in enumerate(axes):
+        #         legend = ax.get_legend()
+        #         if legend:
+        #             legend_fig = plt.figure(figsize=(3, 2))
+        #             new_legend = legend_fig.gca().legend(
+        #                 handles=legend.legendHandles,
+        #                 labels=legend.texts,
+        #                 loc="center",
+        #             )
+        #             legend_fig.canvas.draw()
+        #             legend_filename = f"legend_{i}.png"
+        #             legend_fig.savefig(legend_filename, bbox_inches="tight")
+        #             legend_figs.append(legend_fig)
+        #             plt.close(legend_fig)
+
+        #     for ax in axes:
+        #         ax.legend_ = None
+
+    return fig, legend_figs
+
+
+def _run_umap(umap_model, data_all, labels_all, supervised, title):
+    # UMAP Clustering
+    if not umap_model:
+        umap_model = umap_orig.UMAP(random_state=42)
+        supervised_label_or_none = labels_all[0] if supervised else None
+        title = f"(Supervised) {title}" if supervised else f"(Unsupervised) {title}"
+        _umap = umap_model.fit(data_all[0], y=supervised_label_or_none)
+    else:
+        _umap = umap_model
+
+    return _umap
+
+
+def _check_input_vars(data_all, labels_all, hues_all, hues_colors_all):
+    # Ensures input formats
+    if hues_all is None:
+        hues_all = [None for _ in range(len(data_all))]
+
+    if hues_colors_all is None:
+        hues_colors_all = [None for _ in range(len(data_all))]
+
+    assert len(data_all) == len(labels_all) == len(hues_all) == len(hues_colors_all)
+
+    assert (
+        isinstance(data_all, list)
+        and isinstance(labels_all, list)
+        and isinstance(hues_all, list)
+        and isinstance(hues_colors_all, list)
+    )
+    return data_all, labels_all, hues_all, hues_colors_all
+
+
+def _test(dataset_str="iris"):
+    import matplotlib.pyplot as plt
+    import numpy as np
+    from sklearn.datasets import load_digits, load_iris
+    from sklearn.model_selection import train_test_split
+
+    # Load iris dataset
+    load_dataset = {"iris": load_iris, "mnist": load_digits}[dataset_str]
+
+    dataset = load_dataset()
+    X = dataset.data
+    y = dataset.target
+
+    # Split data into two parts
+    X1, X2, y1, y2 = train_test_split(X, y, test_size=0.5, random_state=42)
+
+    # Call umap function
+    fig, legend_figs, umap_model = umap(
+        data=[X1, X2],
+        labels=[y1, y2],
+        # axes=axes,
+        axes_titles=[f"{dataset_str} Set 1", f"{dataset_str} Set 2"],
+        supervised=True,
+        title=dataset_str,
+        use_independent_legend=True,
+        s=10,
+    )
+
+    # plt.tight_layout()
+    scitex.io.save(fig, f"/tmp/scitex/umap/{dataset_str}.jpg")
+
+    # Save legend figures if any
+    if legend_figs:
+        for i, leg_fig in enumerate(legend_figs):
+            scitex.io.save(leg_fig, f"/tmp/scitex/umap/{dataset_str}_legend_{i}.jpg")
+
+
+main = umap
+
+if __name__ == "__main__":
+    # # Argument Parser
+    # import argparse
+    # parser = argparse.ArgumentParser(description='')
+    # parser.add_argument('--var', '-v', type=int, default=1, help='')
+    # parser.add_argument('--flag', '-f', action='store_true', default=False, help='')
+    # args = parser.parse_args()
+
+    # Main
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(
+        sys, plt, verbose=False, agg=True
+    )
+    _test(dataset_str="mnist")
+    # main()
+    scitex.session.close(CONFIG, verbose=False, notify=False)
+
+# EOF

scitex/ml/feature_extraction/__init__.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-20 10:53:22 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/feature_extraction/__init__.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/feature_extraction/__init__.py"
+
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-10-22 19:51:47 (ywatanabe)"
+# File: __init__.py
+
+import os as __os
+import importlib as __importlib
+import inspect as __inspect
+import warnings as __warnings
+
+# Get the current directory
+current_dir = __os.path.dirname(__file__)
+
+# Iterate through all Python files in the current directory
+for filename in __os.listdir(current_dir):
+    if filename.endswith(".py") and not filename.startswith("__"):
+        module_name = filename[:-3]  # Remove .py extension
+        try:
+            module = __importlib.import_module(f".{module_name}", package=__name__)
+            
+            # Import only functions and classes from the module
+            for name, obj in __inspect.getmembers(module):
+                if __inspect.isfunction(obj) or __inspect.isclass(obj):
+                    if not name.startswith("_"):
+                        globals()[name] = obj
+        except ImportError as e:
+            # Warn about modules that couldn't be imported due to missing dependencies
+            __warnings.warn(
+                f"Could not import {module_name} from scitex.ai.feature_extraction: {str(e)}. "
+                f"Some functionality may be unavailable. "
+                f"Consider installing missing dependencies if you need this module.",
+                ImportWarning,
+                stacklevel=2
+            )
+
+# Clean up temporary variables
+del __os, __importlib, __inspect, __warnings, current_dir
+if 'filename' in locals():
+    del filename
+if 'module_name' in locals():
+    del module_name
+if 'module' in locals():
+    del module
+if 'name' in locals():
+    del name
+if 'obj' in locals():
+    del obj
+
+# EOF

scitex/ml/feature_extraction/vit.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-27 21:36:51 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/ai/feature_extraction/vit.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/feature_extraction/vit.py"
+
+"""
+Functionality:
+    Extracts features from images using Vision Transformer (ViT) models
+Input:
+    Image arrays of arbitrary dimensions
+Output:
+    Feature vectors (1000-dimensional embeddings)
+Prerequisites:
+    torch, PIL, torchvision
+"""
+
+import os as _os
+from typing import Tuple, Union
+
+import torch
+import torch as _torch
+import numpy as np
+from pytorch_pretrained_vit import ViT
+from torchvision import transforms as _transforms
+
+# from ...decorators import batch_torch_fn
+
+
+def _setup_device(device: Union[str, None]) -> str:
+    if device is None:
+        device = "cuda" if _torch.cuda.is_available() else "cpu"
+    return device
+
+
+class VitFeatureExtractor:
+    def __init__(
+        self,
+        model_name="B_16",
+        torch_home="./models",
+        device=None,
+    ):
+        self.valid_models = [
+            "B_16",
+            "B_32",
+            "L_16",
+            "L_32",
+            "B_16_imagenet1k",
+            "B_32_imagenet1k",
+            "L_16_imagenet1k",
+            "L_32_imagenet1k",
+        ]
+        self.model_name = model_name
+        self.torch_home = torch_home
+        self.device = _setup_device(device)
+
+        _os.environ["TORCH_HOME"] = torch_home
+        self._validate_inputs()
+        self.model = ViT(model_name, pretrained=True).to(self.device).eval()
+        self.transform = _transforms.Compose(
+            [
+                _transforms.ToPILImage(),
+                _transforms.Resize(self.model.image_size),
+                _transforms.ToTensor(),
+                _transforms.Normalize(0.5, 0.5),
+            ]
+        )
+
+    def _validate_inputs(self):
+        if self.model_name not in self.valid_models:
+            raise ValueError(f"Invalid model name. Choose from: {self.valid_models}")
+        if not _os.path.exists(self.torch_home):
+            raise FileNotFoundError(f"Model directory not found: {self.torch_home}")
+
+    def _preprocess_array(
+        self,
+        arr: _torch.Tensor,
+        dim: Tuple[int, int],
+        channel_dim: Union[int, None],
+    ) -> _torch.Tensor:
+        # print(f"Input array shape: {arr.shape}")
+
+        orig_shape = arr.shape
+        dim = tuple(d if d >= 0 else len(orig_shape) + d for d in dim)
+
+        perm = list(range(len(orig_shape)))
+        for d in sorted(dim):
+            perm.remove(d)
+            perm.append(d)
+        arr = arr.permute(perm)
+
+        # Flatten all dimensions except the last two (spatial dimensions)
+        batch_shape = arr.shape[:-2]
+        spatial_shape = arr.shape[-2:]
+        arr = arr.reshape(-1, *spatial_shape)
+
+        # Process each image
+        transformed = []
+        for img in arr:
+            img = img.unsqueeze(0)
+            img = img.repeat(3, 1, 1)
+            transformed.append(self.transform(img))
+        result = _torch.stack(transformed)
+        return result, batch_shape
+
+    # @batch_method
+    # @torch_method
+    # @batch_torch_fn
+    def extract_features(
+        self,
+        arr,
+        axis=(-2, -1),
+        dim=None,
+        channel_dim=None,
+        batch_size=None,
+        device="cuda",
+    ):
+
+        processed_arr, batch_shape = self._preprocess_array(
+            arr,
+            axis,
+            channel_dim,
+        )
+        # print(f"Processed shape: {processed_arr.shape}")
+
+        processed_arr = processed_arr.to(self.device)
+        with _torch.no_grad():
+            features = self.model(processed_arr).cpu()
+
+        return features.reshape(*batch_shape, -1)
+
+
+if __name__ == "__main__":
+    import scitex
+
+    extractor = scitex.ai.feature_extraction.VitFeatureExtractor(
+        model_name="B_16_imagenet1k"
+    )
+    tensor = torch.randn(3, 2, 4, 5, 32, 32)
+    processed = extractor.extract_features(tensor, (-2, -1), None)
+    print(processed.shape)
+
+    arr = np.random.rand(3, 2, 4, 5, 32, 32)
+    processed = extractor.extract_features(arr, (-2, -1), None)
+    print(processed.shape)
+    # torch.Size([3, 2, 4, 5, 32, 32])
+
+# EOF

scitex/ml/feature_selection/__init__.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Feature selection utilities for machine learning.
+
+This module provides comprehensive feature selection and importance analysis:
+- Feature importance extraction from various model types
+- Univariate feature selection (ANOVA F-test, chi2, mutual_info)
+- Model-based feature selection (tree importances, L1 coefficients)
+- Cross-fold feature consistency analysis
+- Feature importance aggregation and visualization
+"""
+
+from .feature_selection import (
+    extract_feature_importance,
+    select_features_univariate,
+    analyze_feature_consistency,
+    aggregate_feature_importances,
+    create_feature_importance_dataframe,
+)
+
+__all__ = [
+    "extract_feature_importance",
+    "select_features_univariate",
+    "analyze_feature_consistency",
+    "aggregate_feature_importances",
+    "create_feature_importance_dataframe",
+]
+
+# EOF