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

scitex/ml/metrics/_calc_conf_mat.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-02 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/ml/metrics/_calc_conf_mat.py
+
+"""Calculate confusion matrix."""
+
+__FILE__ = __file__
+
+from typing import Any, Dict, List, Optional
+import numpy as np
+import pandas as pd
+from sklearn.metrics import confusion_matrix as sklearn_confusion_matrix
+from ._normalize_labels import normalize_labels
+
+
+def calc_conf_mat(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    labels: Optional[List] = None,
+    fold: Optional[int] = None,
+    normalize: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Calculate confusion matrix with robust label handling.
+
+    Parameters
+    ----------
+    y_true : np.ndarray
+        True labels (can be str or int)
+    y_pred : np.ndarray
+        Predicted labels (can be str or int)
+    labels : List, optional
+        Expected label list
+    fold : int, optional
+        Fold number for tracking
+    normalize : str, optional
+        'true', 'pred', 'all', or None
+
+    Returns
+    -------
+    Dict[str, Any]
+        {
+            'metric': 'confusion_matrix',
+            'value': pd.DataFrame,
+            'fold': int,
+            'labels': list
+        }
+    """
+    try:
+        y_true_norm, y_pred_norm, label_names, _ = normalize_labels(
+            y_true, y_pred, labels
+        )
+
+        # Calculate confusion matrix
+        cm = sklearn_confusion_matrix(
+            y_true_norm,
+            y_pred_norm,
+            labels=list(range(len(label_names))),
+        )
+
+        # Normalize if requested
+        if normalize == "true":
+            cm = cm.astype("float") / cm.sum(axis=1, keepdims=True)
+        elif normalize == "pred":
+            cm = cm.astype("float") / cm.sum(axis=0, keepdims=True)
+        elif normalize == "all":
+            cm = cm.astype("float") / cm.sum()
+
+        # Convert to DataFrame
+        cm_df = pd.DataFrame(cm, index=label_names, columns=label_names)
+
+        return {
+            "metric": "confusion_matrix",
+            "value": cm_df,
+            "fold": fold,
+            "labels": label_names,
+            "normalize": normalize,
+        }
+    except Exception as e:
+        import sys
+        print(f"ERROR in calc_conf_mat: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        return {
+            "metric": "confusion_matrix",
+            "value": None,
+            "fold": fold,
+            "error": str(e),
+        }
+
+
+# EOF

scitex/ml/metrics/_calc_feature_importance.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-03 04:00:00 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/ml/metrics/_calc_feature_importance.py
+
+"""
+Calculate feature importance from trained models.
+
+This module provides a unified interface for extracting feature importance
+from various model types (tree-based, linear models, etc.).
+"""
+
+from typing import Dict, List, Optional, Tuple
+import numpy as np
+
+
+def calc_feature_importance(
+    model,
+    feature_names: Optional[List[str]] = None,
+    top_n: Optional[int] = None,
+) -> Tuple[Dict[str, float], np.ndarray]:
+    """
+    Calculate feature importance from a trained model.
+
+    Parameters
+    ----------
+    model : object
+        Trained model with feature importance attributes
+        Supports:
+        - Tree-based: feature_importances_ (RandomForest, XGBoost, etc.)
+        - Linear: coef_ (LogisticRegression, LinearSVC, etc.)
+    feature_names : List[str], optional
+        Names of features. If None, uses feature_0, feature_1, ...
+    top_n : int, optional
+        Return only top N most important features
+
+    Returns
+    -------
+    importance_dict : Dict[str, float]
+        Dictionary mapping feature names to importance scores
+    importance_array : np.ndarray
+        Array of importance scores (same order as feature_names)
+
+    Raises
+    ------
+    ValueError
+        If model doesn't support feature importance extraction
+
+    Examples
+    --------
+    >>> from sklearn.ensemble import RandomForestClassifier
+    >>> import numpy as np
+    >>> X = np.random.rand(100, 5)
+    >>> y = np.random.randint(0, 2, 100)
+    >>> model = RandomForestClassifier().fit(X, y)
+    >>> importance_dict, importance_array = calc_feature_importance(
+    ...     model, feature_names=['f1', 'f2', 'f3', 'f4', 'f5']
+    ... )
+    """
+    # Extract importance scores based on model type
+    if hasattr(model, "feature_importances_"):
+        # Tree-based models (RandomForest, XGBoost, etc.)
+        importances = model.feature_importances_
+    elif hasattr(model, "coef_"):
+        # Linear models (LogisticRegression, LinearSVC, etc.)
+        coef = model.coef_
+        if coef.ndim == 2:
+            # For multiclass, use mean absolute coefficient
+            importances = np.abs(coef).mean(axis=0)
+        else:
+            importances = np.abs(coef)
+    else:
+        raise ValueError(
+            f"Model {type(model).__name__} does not support feature importance extraction. "
+            f"Model must have either 'feature_importances_' or 'coef_' attribute."
+        )
+
+    # Generate feature names if not provided
+    if feature_names is None:
+        n_features = len(importances)
+        feature_names = [f"feature_{i}" for i in range(n_features)]
+
+    # Validate feature names match importance array length
+    if len(feature_names) != len(importances):
+        raise ValueError(
+            f"Number of feature names ({len(feature_names)}) "
+            f"does not match number of importances ({len(importances)})"
+        )
+
+    # Create dictionary
+    importance_dict = {
+        name: float(imp) for name, imp in zip(feature_names, importances)
+    }
+
+    # Sort by importance
+    sorted_items = sorted(
+        importance_dict.items(), key=lambda x: x[1], reverse=True
+    )
+
+    # Apply top_n filter if requested
+    if top_n is not None:
+        sorted_items = sorted_items[:top_n]
+
+    # Return sorted dictionary and original array
+    return dict(sorted_items), importances
+
+
+def calc_permutation_importance(
+    model,
+    X: np.ndarray,
+    y: np.ndarray,
+    feature_names: Optional[List[str]] = None,
+    n_repeats: int = 10,
+    random_state: Optional[int] = None,
+    scoring: Optional[str] = None,
+) -> Tuple[Dict[str, float], Dict[str, float]]:
+    """
+    Calculate permutation feature importance.
+
+    More reliable than built-in importance for some models, but slower.
+
+    Parameters
+    ----------
+    model : object
+        Trained model
+    X : np.ndarray
+        Feature matrix
+    y : np.ndarray
+        Target vector
+    feature_names : List[str], optional
+        Names of features
+    n_repeats : int, default 10
+        Number of times to permute each feature
+    random_state : int, optional
+        Random seed for reproducibility
+    scoring : str, optional
+        Scoring metric (default uses model's score method)
+
+    Returns
+    -------
+    importance_mean : Dict[str, float]
+        Mean importance for each feature
+    importance_std : Dict[str, float]
+        Standard deviation of importance for each feature
+    """
+    from sklearn.inspection import permutation_importance
+
+    # Calculate permutation importance
+    result = permutation_importance(
+        model,
+        X,
+        y,
+        n_repeats=n_repeats,
+        random_state=random_state,
+        scoring=scoring,
+    )
+
+    # Generate feature names if not provided
+    if feature_names is None:
+        n_features = X.shape[1]
+        feature_names = [f"feature_{i}" for i in range(n_features)]
+
+    # Create dictionaries
+    importance_mean = {
+        name: float(imp)
+        for name, imp in zip(feature_names, result.importances_mean)
+    }
+    importance_std = {
+        name: float(imp)
+        for name, imp in zip(feature_names, result.importances_std)
+    }
+
+    # Sort by mean importance
+    sorted_names = sorted(
+        importance_mean.keys(), key=lambda x: importance_mean[x], reverse=True
+    )
+    importance_mean = {name: importance_mean[name] for name in sorted_names}
+    importance_std = {name: importance_std[name] for name in sorted_names}
+
+    return importance_mean, importance_std
+
+
+# EOF

scitex/ml/metrics/_calc_mcc.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-02 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/ml/metrics/_calc_mcc.py
+
+"""Calculate Matthews Correlation Coefficient."""
+
+__FILE__ = __file__
+
+from typing import Any, Dict, List, Optional
+import numpy as np
+from sklearn.metrics import matthews_corrcoef
+from ._normalize_labels import normalize_labels
+
+
+def calc_mcc(
+    y_true: np.ndarray,
+    y_pred: np.ndarray,
+    labels: Optional[List] = None,
+    fold: Optional[int] = None,
+) -> Dict[str, Any]:
+    """
+    Calculate Matthews Correlation Coefficient with robust label handling.
+
+    Parameters
+    ----------
+    y_true : np.ndarray
+        True labels (can be str or int)
+    y_pred : np.ndarray
+        Predicted labels (can be str or int)
+    labels : List, optional
+        Expected label list
+    fold : int, optional
+        Fold number for tracking
+
+    Returns
+    -------
+    Dict[str, Any]
+        {'metric': 'mcc', 'value': float, 'fold': int}
+    """
+    try:
+        y_true_norm, y_pred_norm, label_names, _ = normalize_labels(
+            y_true, y_pred, labels
+        )
+        value = matthews_corrcoef(y_true_norm, y_pred_norm)
+        return {
+            "metric": "mcc",
+            "value": float(value),
+            "fold": fold,
+            "labels": label_names,
+        }
+    except Exception as e:
+        return {
+            "metric": "mcc",
+            "value": np.nan,
+            "fold": fold,
+            "error": str(e),
+        }
+
+
+# EOF

scitex/ml/metrics/_calc_pre_rec_auc.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-02 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/ml/metrics/_calc_pre_rec_auc.py
+
+"""Calculate Precision-Recall AUC."""
+
+__FILE__ = __file__
+
+from typing import Any, Dict, List, Optional
+import numpy as np
+from sklearn.metrics import average_precision_score, precision_recall_curve
+
+
+def calc_pre_rec_auc(
+    y_true: np.ndarray,
+    y_proba: np.ndarray,
+    labels: Optional[List] = None,
+    fold: Optional[int] = None,
+    return_curve: bool = False,
+) -> Dict[str, Any]:
+    """
+    Calculate Precision-Recall AUC with robust handling.
+
+    Parameters
+    ----------
+    y_true : np.ndarray
+        True labels (can be str or int)
+    y_proba : np.ndarray
+        Predicted probabilities
+    labels : List, optional
+        Expected label list
+    fold : int, optional
+        Fold number for tracking
+    return_curve : bool
+        Whether to return PR curve data
+
+    Returns
+    -------
+    Dict[str, Any]
+        {'metric': 'pr_auc', 'value': float, 'fold': int}
+    """
+    try:
+        # Normalize labels
+        if labels is not None:
+            unique_labels = np.unique(y_true)
+            label_names = labels
+            # If data contains integers, assume they map to label indices
+            if isinstance(unique_labels[0], (int, np.integer)):
+                y_true_norm = y_true.astype(int)
+            else:
+                # Data contains label names
+                label_map = {label: idx for idx, label in enumerate(labels)}
+                y_true_norm = np.array([label_map[y] for y in y_true])
+        else:
+            unique_labels = sorted(np.unique(y_true))
+            label_names = unique_labels
+            if isinstance(unique_labels[0], (int, np.integer)):
+                y_true_norm = y_true.astype(int)
+            else:
+                label_map = {label: idx for idx, label in enumerate(unique_labels)}
+                y_true_norm = np.array([label_map[y] for y in y_true])
+
+        # Handle binary vs multiclass
+        if y_proba.ndim == 2 and y_proba.shape[1] == 2:
+            # Binary with 2 columns
+            y_proba_pos = y_proba[:, 1]
+            auc_score = average_precision_score(y_true_norm, y_proba_pos)
+        elif y_proba.ndim == 2 and y_proba.shape[1] > 2:
+            # Multiclass
+            from sklearn.preprocessing import label_binarize
+
+            n_classes = y_proba.shape[1]
+            y_true_bin = label_binarize(y_true_norm, classes=range(n_classes))
+            auc_score = average_precision_score(
+                y_true_bin, y_proba, average="weighted"
+            )
+        else:
+            # 1D array
+            auc_score = average_precision_score(y_true_norm, y_proba)
+
+        result = {
+            "metric": "pr_auc",
+            "value": float(auc_score),
+            "fold": fold,
+            "labels": label_names,
+        }
+
+        if return_curve and y_proba.ndim <= 2 and (
+            y_proba.ndim == 1 or y_proba.shape[1] == 2
+        ):
+            # Only for binary classification
+            try:
+                y_proba_curve = y_proba[:, 1] if y_proba.ndim == 2 else y_proba
+                precision, recall, thresholds = precision_recall_curve(
+                    y_true_norm, y_proba_curve
+                )
+                result["curve"] = {
+                    "precision": precision.tolist(),
+                    "recall": recall.tolist(),
+                    "thresholds": thresholds.tolist(),
+                }
+            except:
+                pass
+
+        return result
+    except Exception as e:
+        return {
+            "metric": "pr_auc",
+            "value": np.nan,
+            "fold": fold,
+            "error": str(e),
+        }
+
+
+# EOF

scitex/ml/metrics/_calc_roc_auc.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-02 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/ml/metrics/_calc_roc_auc.py
+
+"""Calculate ROC AUC score."""
+
+__FILE__ = __file__
+
+from typing import Any, Dict, List, Optional
+import numpy as np
+from sklearn.metrics import roc_auc_score, roc_curve
+
+
+def calc_roc_auc(
+    y_true: np.ndarray,
+    y_proba: np.ndarray,
+    labels: Optional[List] = None,
+    fold: Optional[int] = None,
+    return_curve: bool = False,
+) -> Dict[str, Any]:
+    """
+    Calculate ROC AUC score with robust handling.
+
+    Parameters
+    ----------
+    y_true : np.ndarray
+        True labels (can be str or int)
+    y_proba : np.ndarray
+        Predicted probabilities
+    labels : List, optional
+        Expected label list
+    fold : int, optional
+        Fold number for tracking
+    return_curve : bool
+        Whether to return ROC curve data
+
+    Returns
+    -------
+    Dict[str, Any]
+        {'metric': 'roc_auc', 'value': float, 'fold': int}
+    """
+    try:
+        # Normalize labels
+        if labels is not None:
+            unique_labels = np.unique(y_true)
+            label_names = labels
+            # If data contains integers, assume they map to label indices
+            if isinstance(unique_labels[0], (int, np.integer)):
+                y_true_norm = y_true.astype(int)
+            else:
+                # Data contains label names
+                label_map = {label: idx for idx, label in enumerate(labels)}
+                y_true_norm = np.array([label_map[y] for y in y_true])
+        else:
+            unique_labels = sorted(np.unique(y_true))
+            label_names = unique_labels
+            if isinstance(unique_labels[0], (int, np.integer)):
+                y_true_norm = y_true.astype(int)
+            else:
+                label_map = {label: idx for idx, label in enumerate(unique_labels)}
+                y_true_norm = np.array([label_map[y] for y in y_true])
+
+        # Handle binary vs multiclass
+        if y_proba.ndim == 2 and y_proba.shape[1] == 2:
+            # Binary with 2 columns
+            y_proba_pos = y_proba[:, 1]
+            auc_score = roc_auc_score(y_true_norm, y_proba_pos)
+        elif y_proba.ndim == 2 and y_proba.shape[1] > 2:
+            # Multiclass
+            auc_score = roc_auc_score(
+                y_true_norm, y_proba, multi_class="ovr", average="weighted"
+            )
+        else:
+            # 1D array
+            auc_score = roc_auc_score(y_true_norm, y_proba)
+
+        result = {
+            "metric": "roc_auc",
+            "value": float(auc_score),
+            "fold": fold,
+            "labels": label_names,
+        }
+
+        if return_curve and y_proba.ndim <= 2 and (
+            y_proba.ndim == 1 or y_proba.shape[1] == 2
+        ):
+            # Only for binary classification
+            try:
+                y_proba_curve = y_proba[:, 1] if y_proba.ndim == 2 else y_proba
+                fpr, tpr, thresholds = roc_curve(y_true_norm, y_proba_curve)
+                result["curve"] = {
+                    "fpr": fpr.tolist(),
+                    "tpr": tpr.tolist(),
+                    "thresholds": thresholds.tolist(),
+                }
+            except:
+                pass
+
+        return result
+    except Exception as e:
+        return {
+            "metric": "roc_auc",
+            "value": np.nan,
+            "fold": fold,
+            "error": str(e),
+        }
+
+
+# EOF