scitex 2.5.0__py3-none-any.whl → 2.7.3__py3-none-any.whl

scitex/ai/classification/timeseries/__init__.py

@@ -26,14 +26,12 @@ from ._normalize_timestamp import normalize_timestamp
 __all__ = [
     # Main time series CV splitters
     "TimeSeriesStratifiedSplit",
-    "TimeSeriesBlockingSplit", 
+    "TimeSeriesBlockingSplit",
     "TimeSeriesSlidingWindowSplit",
     "TimeSeriesCalendarSplit",
-    
     # Support classes
     "TimeSeriesStrategy",
     "TimeSeriesMetadata",
-    
     # Timestamp normalizer
     "normalize_timestamp",
-]
+]

scitex/ai/classification/timeseries/_normalize_timestamp.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -69,6 +70,8 @@ ALTERNATIVE_FORMATS = [
 ]
 
 """Functions & Classes"""
+
+
 def normalize_timestamp(
     timestamp: Union[datetime, str, int, float],
     return_as: str = "str",

scitex/ai/clustering/_pca.py

@@ -22,7 +22,6 @@ def pca(
     add_super_imposed=False,
     palette="viridis",
 ):
-
     assert len(data_all) == len(labels_all)
 
     if isinstance(data_all, list):

scitex/ai/clustering/_umap.py

@@ -8,7 +8,6 @@
 This script does XYZ.
 """
 
-
 """
 Imports
 """
@@ -159,7 +158,7 @@ def _plot(
             axes[0].get_figure()
             # axes
             if isinstance(
-                axes, (np.ndarray, scitex.plt._subplots._AxesWrapper.AxesWrapper)
+                axes, (np.ndarray, scitex.plt._subplots.AxesWrapper)
             )
             # axis
             else axes.get_figure()

scitex/ai/feature_extraction/__init__.py

@@ -3,7 +3,9 @@
 # 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"
+THIS_FILE = (
+    "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/feature_extraction/__init__.py"
+)
 
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
@@ -24,7 +26,7 @@ for filename in __os.listdir(current_dir):
         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):
@@ -37,20 +39,20 @@ for filename in __os.listdir(current_dir):
                 f"Some functionality may be unavailable. "
                 f"Consider installing missing dependencies if you need this module.",
                 ImportWarning,
-                stacklevel=2
+                stacklevel=2,
             )
 
 # Clean up temporary variables
 del __os, __importlib, __inspect, __warnings, current_dir
-if 'filename' in locals():
+if "filename" in locals():
     del filename
-if 'module_name' in locals():
+if "module_name" in locals():
     del module_name
-if 'module' in locals():
+if "module" in locals():
     del module
-if 'name' in locals():
+if "name" in locals():
     del name
-if 'obj' in locals():
+if "obj" in locals():
     del obj
 
 # EOF

scitex/ai/feature_extraction/vit.py

@@ -116,7 +116,6 @@ class VitFeatureExtractor:
         batch_size=None,
         device="cuda",
     ):
-
         processed_arr, batch_shape = self._preprocess_array(
             arr,
             axis,

scitex/ai/feature_selection/feature_selection.py

@@ -77,8 +77,7 @@ def extract_feature_importance(
         elif method == "coef":
             if not hasattr(model, "coef_"):
                 raise ValueError(
-                    f"Model {type(model).__name__} does not have "
-                    f"coef_ attribute"
+                    f"Model {type(model).__name__} does not have coef_ attribute"
                 )
             # Use absolute values for multi-class or single coefficient vector
             coef = model.coef_
@@ -225,12 +224,8 @@ def analyze_feature_consistency(
     )
 
     # Identify stable and unstable features
-    stable_features = [
-        f for f, count in feature_frequency.items() if count == n_folds
-    ]
-    unstable_features = [
-        f for f, count in feature_frequency.items() if count == 1
-    ]
+    stable_features = [f for f, count in feature_frequency.items() if count == n_folds]
+    unstable_features = [f for f, count in feature_frequency.items() if count == 1]
 
     # Calculate consistency score (average selection frequency)
     consistency_score = (

scitex/ai/metrics/_calc_conf_mat.py

@@ -79,8 +79,10 @@ def calc_conf_mat(
         }
     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",

scitex/ai/metrics/_calc_feature_importance.py

@@ -93,9 +93,7 @@ def calc_feature_importance(
     }
 
     # Sort by importance
-    sorted_items = sorted(
-        importance_dict.items(), key=lambda x: x[1], reverse=True
-    )
+    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:
@@ -162,12 +160,10 @@ def calc_permutation_importance(
 
     # Create dictionaries
     importance_mean = {
-        name: float(imp)
-        for name, imp in zip(feature_names, result.importances_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)
+        name: float(imp) for name, imp in zip(feature_names, result.importances_std)
     }
 
     # Sort by mean importance

scitex/ai/metrics/_calc_pre_rec_auc.py

@@ -72,9 +72,7 @@ def calc_pre_rec_auc(
 
             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"
-            )
+            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)
@@ -86,8 +84,10 @@ def calc_pre_rec_auc(
             "labels": label_names,
         }
 
-        if return_curve and y_proba.ndim <= 2 and (
-            y_proba.ndim == 1 or y_proba.shape[1] == 2
+        if (
+            return_curve
+            and y_proba.ndim <= 2
+            and (y_proba.ndim == 1 or y_proba.shape[1] == 2)
         ):
             # Only for binary classification
             try:

scitex/ai/metrics/_calc_roc_auc.py

@@ -82,8 +82,10 @@ def calc_roc_auc(
             "labels": label_names,
         }
 
-        if return_curve and y_proba.ndim <= 2 and (
-            y_proba.ndim == 1 or y_proba.shape[1] == 2
+        if (
+            return_curve
+            and y_proba.ndim <= 2
+            and (y_proba.ndim == 1 or y_proba.shape[1] == 2)
         ):
             # Only for binary classification
             try:

scitex/ai/metrics/_calc_seizure_prediction_metrics.py

@@ -21,6 +21,7 @@ Clinical Targets (FDA guidelines):
   - FP/h ≤ 0.2
   - Time in warning ≤ 20%
 """
+
 from __future__ import annotations
 from typing import Dict
 import numpy as np
@@ -112,9 +113,7 @@ def calc_seizure_window_prediction_metrics(
     # False positives per hour
     n_interictal = interictal_mask.sum()
     total_interictal_hours = (n_interictal * window_duration_min) / 60.0
-    fp_per_hour = (
-        fp / total_interictal_hours if total_interictal_hours > 0 else 0.0
-    )
+    fp_per_hour = fp / total_interictal_hours if total_interictal_hours > 0 else 0.0
 
     # Time in warning (% of total time in alarm state)
     total_windows = len(y_pred)
@@ -252,9 +251,7 @@ def calc_seizure_event_prediction_metrics(
     # False positives per hour
     n_interictal = interictal_mask.sum()
     total_interictal_hours = (n_interictal * window_duration_min) / 60.0
-    fp_per_hour = (
-        fp / total_interictal_hours if total_interictal_hours > 0 else 0.0
-    )
+    fp_per_hour = fp / total_interictal_hours if total_interictal_hours > 0 else 0.0
 
     # Time in warning (% of total time in alarm state)
     total_windows = len(y_pred)
@@ -336,10 +333,12 @@ def main(args):
     # Create labels and metadata with seizure_id for event-based metrics
     y_true = np.array(["interictal_control"] * n_windows)
     y_pred = np.array(["interictal_control"] * n_windows)
-    metadata = pd.DataFrame({
-        "seizure_type": ["interictal_control"] * n_windows,
-        "seizure_id": [None] * n_windows  # seizure_id for event-based metrics
-    })
+    metadata = pd.DataFrame(
+        {
+            "seizure_type": ["interictal_control"] * n_windows,
+            "seizure_id": [None] * n_windows,  # seizure_id for event-based metrics
+        }
+    )
 
     # Add TWO seizure events (event 1: 100-119, event 2: 500-529)
     event1_indices = list(range(100, 120))  # 20 windows
@@ -353,7 +352,9 @@ def main(args):
     metadata.loc[event2_indices, "seizure_type"] = "seizure"
     metadata.loc[event2_indices, "seizure_id"] = "sz_002"
 
-    logger.info(f"Created 2 seizure events spanning {len(seizure_indices)} windows total")
+    logger.info(
+        f"Created 2 seizure events spanning {len(seizure_indices)} windows total"
+    )
     logger.info(f"  Event 1 (sz_001): 20 windows")
     logger.info(f"  Event 2 (sz_002): 30 windows")
 
@@ -361,12 +362,14 @@ def main(args):
     # For event-based demo: detect only 1 window from event 1, most of event 2
     n_detect = int(len(seizure_indices) * args.sensitivity)
     # Detect 1 window from event 1, rest from event 2
-    detected_indices = [event1_indices[0]] + event2_indices[:n_detect-1]
+    detected_indices = [event1_indices[0]] + event2_indices[: n_detect - 1]
     y_pred[detected_indices] = "seizure"
 
-    logger.info(f"Simulating detection of {n_detect}/{len(seizure_indices)} seizure windows")
+    logger.info(
+        f"Simulating detection of {n_detect}/{len(seizure_indices)} seizure windows"
+    )
     logger.info(f"  Event 1: 1/20 windows detected")
-    logger.info(f"  Event 2: {n_detect-1}/30 windows detected")
+    logger.info(f"  Event 2: {n_detect - 1}/30 windows detected")
 
     # Add some false positives
     fp_indices = [200, 300, 400, 600, 700]
@@ -402,7 +405,9 @@ def main(args):
         f"  Meets sensitivity target (≥90%): {metrics_window['meets_sensitivity_target']}"
     )
     logger.info(f"  Meets FP/h target (≤0.2): {metrics_window['meets_fp_target']}")
-    logger.info(f"  Meets time in warning target (≤20%): {metrics_window['meets_tiw_target']}")
+    logger.info(
+        f"  Meets time in warning target (≤20%): {metrics_window['meets_tiw_target']}"
+    )
     logger.info("=" * 70)
 
     # Calculate EVENT-BASED metrics
@@ -433,7 +438,9 @@ def main(args):
         f"  Meets sensitivity target (≥90%): {metrics_event['meets_sensitivity_target']}"
     )
     logger.info(f"  Meets FP/h target (≤0.2): {metrics_event['meets_fp_target']}")
-    logger.info(f"  Meets time in warning target (≤20%): {metrics_event['meets_tiw_target']}")
+    logger.info(
+        f"  Meets time in warning target (≤20%): {metrics_event['meets_tiw_target']}"
+    )
     logger.info("=" * 70)
 
     # Comparison summary
@@ -441,12 +448,20 @@ def main(args):
     logger.info("=" * 70)
     logger.info("KEY DIFFERENCE DEMONSTRATION")
     logger.info("=" * 70)
-    logger.info(f"Window-based sensitivity: {metrics_window['seizure_sensitivity']:.1f}% (detected {metrics_window['n_true_positives']}/{metrics_window['n_seizure_windows']} windows)")
-    logger.info(f"Event-based sensitivity:  {metrics_event['seizure_sensitivity']:.1f}% (detected {metrics_event['n_detected_events']}/{metrics_event['n_seizure_events']} events)")
+    logger.info(
+        f"Window-based sensitivity: {metrics_window['seizure_sensitivity']:.1f}% (detected {metrics_window['n_true_positives']}/{metrics_window['n_seizure_windows']} windows)"
+    )
+    logger.info(
+        f"Event-based sensitivity:  {metrics_event['seizure_sensitivity']:.1f}% (detected {metrics_event['n_detected_events']}/{metrics_event['n_seizure_events']} events)"
+    )
     logger.info("")
     logger.info("Interpretation:")
-    logger.info("  - Window-based: Detected only 1 window from Event 1 → Low sensitivity")
-    logger.info("  - Event-based: Detected at least 1 window from BOTH events → 100% sensitivity!")
+    logger.info(
+        "  - Window-based: Detected only 1 window from Event 1 → Low sensitivity"
+    )
+    logger.info(
+        "  - Event-based: Detected at least 1 window from BOTH events → 100% sensitivity!"
+    )
     logger.info("  - Clinical relevance: One timely alarm per seizure is sufficient")
     logger.info("=" * 70)
 

scitex/ai/metrics/_calc_silhouette_score.py

@@ -452,7 +452,7 @@ def _nearest_cluster_distance_block(X, labels, metric, n_jobs=1, **kwds):
             X[_np.where(labels == label_a)[0]],
             X[_np.where(labels == label_b)[0]],
             metric,
-            **kwds
+            **kwds,
         )
         for label_a, label_b in _combinations(unique_labels, 2)
     )
@@ -460,7 +460,6 @@ def _nearest_cluster_distance_block(X, labels, metric, n_jobs=1, **kwds):
     for (label_a, label_b), (values_a, values_b) in zip(
         _combinations(unique_labels, 2), values
     ):
-
         indices_a = _np.where(labels == label_a)[0]
         inter_dist[indices_a] = _np.minimum(values_a, inter_dist[indices_a])
         del indices_a
@@ -493,7 +492,6 @@ if __name__ == "__main__":
     print("Block silhouette parallel (%fs): %f" % (t, s))
 
 
-
 # Backward compatibility aliases (deprecated, will be removed in future)
 silhouette_score_slow = calc_silhouette_score_slow
 silhouette_samples_slow = calc_silhouette_samples_slow

scitex/ai/optim/Ranger_Deep_Learning_Optimizer/ranger/ranger.py

@@ -27,7 +27,6 @@ from torch.optim.optimizer import Optimizer, required
 
 
 class Ranger(Optimizer):
-
     def __init__(
         self,
         params,
@@ -42,7 +41,6 @@ class Ranger(Optimizer):
         use_gc=True,
         gc_conv_only=False,
     ):
-
         # parameter checks
         if not 0.0 <= alpha <= 1.0:
             raise ValueError(f"Invalid slow update rate: {alpha}")
@@ -110,7 +108,6 @@ class Ranger(Optimizer):
 
         # Evaluate averages and grad, update param tensors
         for group in self.param_groups:
-
             for p in group["params"]:
                 if p.grad is None:
                     continue

scitex/ai/optim/Ranger_Deep_Learning_Optimizer/ranger/ranger2020.py

@@ -41,7 +41,6 @@ def centralized_gradient(x, use_gc=True, gc_conv_only=False):
 
 
 class Ranger(Optimizer):
-
     def __init__(
         self,
         params,
@@ -57,7 +56,6 @@ class Ranger(Optimizer):
         gc_conv_only=False,
         gc_loc=True,
     ):
-
         # parameter checks
         if not 0.0 <= alpha <= 1.0:
             raise ValueError(f"Invalid slow update rate: {alpha}")
@@ -126,7 +124,6 @@ class Ranger(Optimizer):
 
         # Evaluate averages and grad, update param tensors
         for group in self.param_groups:
-
             for p in group["params"]:
                 if p.grad is None:
                     continue

scitex/ai/optim/Ranger_Deep_Learning_Optimizer/ranger/ranger913A.py

@@ -24,7 +24,6 @@ import itertools as it
 
 
 class RangerVA(Optimizer):
-
     def __init__(
         self,
         params,
@@ -109,7 +108,6 @@ class RangerVA(Optimizer):
 
         # Evaluate averages and grad, update param tensors
         for group in self.param_groups:
-
             for p in group["params"]:
                 if p.grad is None:
                     continue
@@ -195,7 +193,6 @@ class RangerVA(Optimizer):
                     p_data_fp32.addcdiv_(-step_size, exp_avg, denomf)
 
                 else:
-
                     denom = exp_avg_sq.sqrt().add_(group["eps"])
                     p_data_fp32.addcdiv_(-step_size * group["lr"], exp_avg, denom)
 

scitex/ai/optim/_optimizers.py

@@ -43,7 +43,7 @@ def get_optimizer(name: str):
 
     if name not in optimizers:
         raise ValueError(
-            f"Unknown optimizer: {name}. " f"Available: {list(optimizers.keys())}"
+            f"Unknown optimizer: {name}. Available: {list(optimizers.keys())}"
         )
 
     return optimizers[name]

scitex/ai/plt/__init__.py

@@ -6,7 +6,12 @@ but re-exported here for backward compatibility. New code should import directly
 from scitex.ai.metrics instead.
 """
 
-from ._stx_conf_mat import calc_bACC_from_conf_mat, calc_bacc_from_conf_mat, stx_conf_mat, conf_mat
+from ._stx_conf_mat import (
+    calc_bACC_from_conf_mat,
+    calc_bacc_from_conf_mat,
+    stx_conf_mat,
+    conf_mat,
+)
 from ._plot_learning_curve import (
     plot_learning_curve,
     _prepare_metrics_df,

scitex/ai/plt/_plot_feature_importance.py

@@ -100,9 +100,7 @@ def plot_feature_importance(
     )
 
     # Format feature names (replace underscores, title case)
-    formatted_names = [
-        name.replace("_", " ").title() for name in sorted_names
-    ]
+    formatted_names = [name.replace("_", " ").title() for name in sorted_names]
 
     ax.set_yticks(y_pos)
     ax.set_yticklabels(formatted_names, fontsize=9)

scitex/ai/plt/_plot_learning_curve.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -48,9 +49,7 @@ def _plot_training_data(ax, metrics_df, metric_key, linewidth=1, color=None):
     if color is None:
         color = str2hex("blue")
 
-    is_training = scitex.str.search(
-        "^[Tt]rain(ing)?", metrics_df.step, as_bool=True
-    )[0]
+    is_training = scitex.str.search("^[Tt]rain(ing)?", metrics_df.step, as_bool=True)[0]
     training_df = metrics_df[is_training]
 
     if len(training_df) > 0:
@@ -127,9 +126,7 @@ def _select_epoch_ticks(metrics_df, max_n_ticks=4):
     """Select representative epoch tick positions and labels."""
     unique_epochs = metrics_df["i_epoch"].drop_duplicates().values
     epoch_starts = (
-        metrics_df[metrics_df["i_batch"] == 0]["i_global"]
-        .drop_duplicates()
-        .values
+        metrics_df[metrics_df["i_batch"] == 0]["i_global"].drop_duplicates().values
     )
 
     if len(epoch_starts) > max_n_ticks:
@@ -215,20 +212,14 @@ def plot_learning_curve(
         ax = _configure_accuracy_axis(ax, metric_key)
 
         # Plot training data (line)
-        ax = _plot_training_data(
-            ax, metrics_df, metric_key, linewidth=linewidth
-        )
+        ax = _plot_training_data(ax, metrics_df, metric_key, linewidth=linewidth)
 
         # Plot validation data (scatter)
-        ax = _plot_validation_data(
-            ax, metrics_df, metric_key, markersize=scattersize
-        )
+        ax = _plot_validation_data(ax, metrics_df, metric_key, markersize=scattersize)
 
         # Plot test data if it exists (scatter)
         if "Test" in metrics_df["step"].values:
-            ax = _plot_test_data(
-                ax, metrics_df, metric_key, markersize=scattersize
-            )
+            ax = _plot_test_data(ax, metrics_df, metric_key, markersize=scattersize)
 
     # Save if path provided
     if spath is not None:
@@ -253,9 +244,7 @@ def main(args):
             loss = 0.7 * np.exp(-i_global / 200) + 0.1 * np.random.rand()
             acc = min(
                 0.95,
-                0.3
-                + 0.6 * (1 - np.exp(-i_global / 300))
-                + 0.05 * np.random.rand(),
+                0.3 + 0.6 * (1 - np.exp(-i_global / 300)) + 0.05 * np.random.rand(),
             )
             data.append(
                 {
@@ -272,9 +261,7 @@ def main(args):
         val_loss = 0.75 * np.exp(-i_global / 200) + 0.15 * np.random.rand()
         val_acc = min(
             0.92,
-            0.25
-            + 0.6 * (1 - np.exp(-i_global / 300))
-            + 0.08 * np.random.rand(),
+            0.25 + 0.6 * (1 - np.exp(-i_global / 300)) + 0.08 * np.random.rand(),
         )
         data.append(
             {
@@ -301,9 +288,7 @@ def main(args):
 
 def parse_args() -> argparse.Namespace:
     """Parse command line arguments."""
-    parser = argparse.ArgumentParser(
-        description="Demo learning curve plotting"
-    )
+    parser = argparse.ArgumentParser(description="Demo learning curve plotting")
     return parser.parse_args()
 
 

scitex/ai/plt/_plot_optuna_study.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -143,6 +144,8 @@ optuna_study = plot_optuna_study
 
 
 """Functions & Classes"""
+
+
 def main(args):
     """
     Demonstrate Optuna study visualization.
@@ -158,9 +161,7 @@ def main(args):
 
 def parse_args() -> argparse.Namespace:
     """Parse command line arguments."""
-    parser = argparse.ArgumentParser(
-        description="Visualize Optuna study results"
-    )
+    parser = argparse.ArgumentParser(description="Visualize Optuna study results")
     parser.add_argument(
         "--lpath",
         type=str,

scitex/ai/plt/_plot_pre_rec_curve.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -69,7 +70,7 @@ def plot_pre_rec_curve(true_class, pred_proba, labels, ax=None, spath=None):
         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)
+    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:
@@ -91,9 +92,7 @@ def plot_pre_rec_curve(true_class, pred_proba, labels, ax=None, spath=None):
                 true_class_i_onehot,
                 pred_proba_i,
             )
-            pre_rec_auc[i] = average_precision_score(
-                true_class_i_onehot, pred_proba_i
-            )
+            pre_rec_auc[i] = average_precision_score(true_class_i_onehot, pred_proba_i)
         except Exception as e:
             print(e)
             precision[i], recall[i], threshold[i], pre_rec_auc[i] = (
@@ -106,8 +105,8 @@ def plot_pre_rec_curve(true_class, pred_proba, labels, ax=None, spath=None):
     ## Average precision: micro and macro
 
     # A "micro-average": quantifying score on all classes jointly
-    precision["micro"], recall["micro"], threshold["micro"] = (
-        precision_recall_curve(true_class_onehot.ravel(), pred_proba.ravel())
+    precision["micro"], recall["micro"], threshold["micro"] = precision_recall_curve(
+        true_class_onehot.ravel(), pred_proba.ravel()
     )
     pre_rec_auc["micro"] = average_precision_score(
         true_class_onehot, pred_proba, average="micro"
@@ -157,9 +156,7 @@ def plot_pre_rec_curve(true_class, pred_proba, labels, ax=None, spath=None):
 
         # ax.annotate("f1={0:0.1f}".format(f_score), xy=(0.9, y[45] + 0.02))
         x_f, y_f = _solve_intersection(f_score, 0.5, 0.5)
-        ax.annotate(
-            "f1={0:0.1f}".format(f_score), xy=(x_f - 0.1, y_f - 0.1 * 0.5)
-        )
+        ax.annotate("f1={0:0.1f}".format(f_score), xy=(x_f - 0.1, y_f - 0.1 * 0.5))
         # ax.annotate("f1={0:0.1f}".format(f_score), xy=(y[35] - 0.02 * (3 - i_f), 0.85))
 
     lines.append(l)
@@ -176,9 +173,7 @@ def plot_pre_rec_curve(true_class, pred_proba, labels, ax=None, spath=None):
     for i in range(n_classes):
         (l,) = ax.plot(recall[i], precision[i], color=colors[i], lw=2)
         lines.append(l)
-        legends.append(
-            "{0} (AUC = {1:0.2f})" "".format(labels[i], pre_rec_auc[i])
-        )
+        legends.append("{0} (AUC = {1:0.2f})".format(labels[i], pre_rec_auc[i]))
 
     # fig = plt.gcf()
     fig.subplots_adjust(bottom=0.25)
@@ -201,6 +196,7 @@ def plot_pre_rec_curve(true_class, pred_proba, labels, ax=None, spath=None):
     # 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
         stx.io.save(fig, str(spath_abs), use_caller_path=False)
@@ -246,9 +242,7 @@ def main(args):
 
 def parse_args() -> argparse.Namespace:
     """Parse command line arguments."""
-    parser = argparse.ArgumentParser(
-        description="Demo Precision-Recall curve plotting"
-    )
+    parser = argparse.ArgumentParser(description="Demo Precision-Recall curve plotting")
     return parser.parse_args()