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

scitex/ai/classification/timeseries/_TimeSeriesMetadata.py

@@ -18,10 +18,10 @@ from typing import Optional, Dict, Tuple, Any
 class TimeSeriesMetadata:
     """
     Metadata about the time series data.
-    
+
     This dataclass captures essential characteristics of time series data
     that inform the selection of appropriate cross-validation strategies.
-    
+
     Attributes
     ----------
     n_samples : int
@@ -46,12 +46,12 @@ class TimeSeriesMetadata:
         Whether classes are balanced (for classification)
     class_distribution : Optional[Dict[Any, float]]
         Mapping of class labels to their proportions
-    
+
     Examples
     --------
     >>> import numpy as np
     >>> from scitex.ai.classification import TimeSeriesMetadata
-    >>> 
+    >>>
     >>> # Create metadata for a dataset
     >>> metadata = TimeSeriesMetadata(
     ...     n_samples=1000,
@@ -66,11 +66,11 @@ class TimeSeriesMetadata:
     ...     is_balanced=True,
     ...     class_distribution={0: 0.5, 1: 0.5}
     ... )
-    >>> 
+    >>>
     >>> print(f"Dataset has {metadata.n_samples} samples")
     >>> print(f"Number of groups: {len(metadata.group_sizes) if metadata.group_sizes else 0}")
     """
-    
+
     n_samples: int
     n_features: int
     n_classes: Optional[int] = None
@@ -82,11 +82,11 @@ class TimeSeriesMetadata:
     max_gap_size: Optional[float] = None
     is_balanced: bool = True
     class_distribution: Optional[Dict[Any, float]] = None
-    
+
     def get_summary(self) -> str:
         """
         Generate human-readable summary of the metadata.
-        
+
         Returns
         -------
         str
@@ -97,33 +97,33 @@ class TimeSeriesMetadata:
             f"  Samples: {self.n_samples}",
             f"  Features: {self.n_features}",
         ]
-        
+
         if self.n_classes is not None:
             lines.append(f"  Classes: {self.n_classes}")
             if self.class_distribution:
                 lines.append(f"  Class balance: {self.class_distribution}")
-        
+
         if self.has_groups and self.group_sizes:
             n_groups = len(self.group_sizes)
             avg_size = sum(self.group_sizes.values()) / n_groups
             lines.append(f"  Groups: {n_groups} (avg size: {avg_size:.1f})")
-        
+
         if self.time_range:
             duration = self.time_range[1] - self.time_range[0]
             lines.append(f"  Time range: {duration:.2f} units")
-        
+
         if self.sampling_rate:
             lines.append(f"  Sampling rate: {self.sampling_rate:.2f} Hz")
-        
+
         if self.has_gaps:
             lines.append(f"  Has gaps: Yes (max: {self.max_gap_size:.2f})")
-        
+
         return "\n".join(lines)
-    
+
     def suggest_strategy(self) -> str:
         """
         Suggest appropriate CV strategy based on metadata.
-        
+
         Returns
         -------
         str
@@ -136,4 +136,4 @@ class TimeSeriesMetadata:
         elif self.sampling_rate and self.sampling_rate > 10:
             return "sliding"  # High frequency data
         else:
-            return "expanding"  # Default for simple time series
+            return "expanding"  # Default for simple time series

scitex/ai/classification/timeseries/_TimeSeriesSlidingWindowSplit.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/ml/classification/timeseries/_TimeSeriesSlidingWindowSplit.py"
-)
+
+__FILE__ = "./src/scitex/ml/classification/timeseries/_TimeSeriesSlidingWindowSplit.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -214,9 +213,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
         train_labels = y[train_indices]
 
         # Find unique classes and their counts
-        unique_classes, class_counts = np.unique(
-            train_labels, return_counts=True
-        )
+        unique_classes, class_counts = np.unique(train_labels, return_counts=True)
 
         if len(unique_classes) < 2:
             # Only one class, no undersampling needed
@@ -301,16 +298,12 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                 available_for_test = (
                     n_samples - min_window_size - (self._n_splits * self.gap)
                 )
-                calculated_test_size = max(
-                    1, available_for_test // self._n_splits
-                )
+                calculated_test_size = max(1, available_for_test // self._n_splits)
 
                 # Set calculated values
                 self.window_size = min_window_size
                 self.test_size = calculated_test_size
-                self.step_size = (
-                    calculated_test_size  # Non-overlapping by default
-                )
+                self.step_size = calculated_test_size  # Non-overlapping by default
 
                 logger.info(
                     f"n_splits={self._n_splits} with expanding_window: "
@@ -321,17 +314,13 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                 # We want: n_samples = window_size + (n_splits * (test_size + gap))
                 # Let's make window_size same as test_size for simplicity
                 available = n_samples - (self._n_splits * self.gap)
-                calculated_test_size = max(
-                    1, available // (self._n_splits + 1)
-                )
+                calculated_test_size = max(1, available // (self._n_splits + 1))
                 calculated_window_size = calculated_test_size
 
                 # Set calculated values
                 self.window_size = calculated_window_size
                 self.test_size = calculated_test_size
-                self.step_size = (
-                    calculated_test_size  # Non-overlapping by default
-                )
+                self.step_size = calculated_test_size  # Non-overlapping by default
 
                 logger.info(
                     f"n_splits={self._n_splits} with fixed window: "
@@ -368,9 +357,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                         train_indices, y, timestamps
                     )
 
-                assert (
-                    len(train_indices) > 0 and len(test_indices) > 0
-                ), "Empty window"
+                assert len(train_indices) > 0 and len(test_indices) > 0, "Empty window"
 
                 yield train_indices, test_indices
 
@@ -381,9 +368,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
             # Fixed sliding window: window slides through data
             total_window = self.window_size + self.gap + self.test_size
 
-            for start in range(
-                0, n_samples - total_window + 1, self.step_size
-            ):
+            for start in range(0, n_samples - total_window + 1, self.step_size):
                 # These positions are in the sorted (temporal) domain
                 train_end = start + self.window_size
                 test_start = train_end + self.gap
@@ -402,9 +387,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                         train_indices, y, timestamps
                     )
 
-                assert (
-                    len(train_indices) > 0 and len(test_indices) > 0
-                ), "Empty window"
+                assert len(train_indices) > 0 and len(test_indices) > 0, "Empty window"
 
                 yield train_indices, test_indices
 
@@ -458,26 +441,20 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                 available_for_test = (
                     n_samples - min_window_size - (self._n_splits * self.gap)
                 )
-                calculated_test_size = max(
-                    1, available_for_test // self._n_splits
-                )
+                calculated_test_size = max(1, available_for_test // self._n_splits)
                 self.window_size = min_window_size
                 self.test_size = calculated_test_size
                 self.step_size = calculated_test_size
             else:
                 available = n_samples - (self._n_splits * self.gap)
-                calculated_test_size = max(
-                    1, available // (self._n_splits + 1)
-                )
+                calculated_test_size = max(1, available // (self._n_splits + 1))
                 calculated_window_size = calculated_test_size
                 self.window_size = calculated_window_size
                 self.test_size = calculated_test_size
                 self.step_size = calculated_test_size
 
         # Calculate validation size from training window
-        val_size = (
-            int(self.window_size * self.val_ratio) if self.val_ratio > 0 else 0
-        )
+        val_size = int(self.window_size * self.val_ratio) if self.val_ratio > 0 else 0
         actual_train_size = self.window_size - val_size
 
         if self.expanding_window:
@@ -508,9 +485,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                     current_val_size = int(train_val_end_pos * self.val_ratio)
                     train_end_pos = train_val_end_pos - current_val_size
                     train_indices = sorted_indices[0:train_end_pos]
-                    val_indices = sorted_indices[
-                        train_end_pos:train_val_end_pos
-                    ]
+                    val_indices = sorted_indices[train_end_pos:train_val_end_pos]
                 else:
                     train_indices = sorted_indices[0:train_val_end_pos]
                     val_indices = np.array([])
@@ -528,9 +503,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                             val_indices, y, timestamps
                         )
 
-                assert (
-                    len(train_indices) > 0 and len(test_indices) > 0
-                ), "Empty window"
+                assert len(train_indices) > 0 and len(test_indices) > 0, "Empty window"
 
                 yield train_indices, val_indices, test_indices
 
@@ -541,9 +514,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
             # Fixed sliding window with validation
             total_window = self.window_size + self.gap + self.test_size
 
-            for start in range(
-                0, n_samples - total_window + 1, self.step_size
-            ):
+            for start in range(0, n_samples - total_window + 1, self.step_size):
                 # These positions are in the sorted (temporal) domain
                 train_end = start + actual_train_size
 
@@ -553,9 +524,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
 
                 # Test comes after validation with gap
                 test_start = (
-                    val_end + self.gap
-                    if val_size > 0
-                    else train_end + self.gap
+                    val_end + self.gap if val_size > 0 else train_end + self.gap
                 )
                 test_end = test_start + self.test_size
 
@@ -565,9 +534,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                 # Extract indices from the temporally sorted sequence
                 train_indices = sorted_indices[start:train_end]
                 val_indices = (
-                    sorted_indices[val_start:val_end]
-                    if val_size > 0
-                    else np.array([])
+                    sorted_indices[val_start:val_end] if val_size > 0 else np.array([])
                 )
                 test_indices = sorted_indices[test_start:test_end]
 
@@ -583,9 +550,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                         )
 
                 # Ensure temporal order is preserved
-                assert (
-                    len(train_indices) > 0 and len(test_indices) > 0
-                ), "Empty window"
+                assert len(train_indices) > 0 and len(test_indices) > 0, "Empty window"
 
                 yield train_indices, val_indices, test_indices
 
@@ -620,9 +585,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
         n_windows = (n_samples - total_window) // self.step_size + 1
         return max(0, n_windows)
 
-    def plot_splits(
-        self, X, y=None, timestamps=None, figsize=(12, 6), save_path=None
-    ):
+    def plot_splits(self, X, y=None, timestamps=None, figsize=(12, 6), save_path=None):
         """
         Visualize the sliding window splits as rectangles.
 
@@ -673,9 +636,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
             original_undersample = self.undersample
             self.undersample = False  # Temporarily disable
             if self.val_ratio > 0:
-                splits_no_undersample = list(
-                    self.split_with_val(X, y, timestamps)
-                )[:10]
+                splits_no_undersample = list(self.split_with_val(X, y, timestamps))[:10]
             else:
                 splits_no_undersample = list(self.split(X, y, timestamps))[:10]
             self.undersample = original_undersample  # Restore
@@ -823,17 +784,14 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                 split_indices_us = splits[fold]
 
                 if len(split_indices_no_us) == 3:  # train, val, test
-                    train_idx_no_us, val_idx_no_us, test_idx_no_us = (
-                        split_indices_no_us
-                    )
+                    train_idx_no_us, val_idx_no_us, test_idx_no_us = split_indices_no_us
                     train_idx_us, val_idx_us, test_idx_us = split_indices_us
 
                     # Find dropped train samples
                     dropped_train = np.setdiff1d(train_idx_no_us, train_idx_us)
                     if len(dropped_train) > 0:
                         dropped_train_positions = [
-                            np.where(time_order == idx)[0][0]
-                            for idx in dropped_train
+                            np.where(time_order == idx)[0][0] for idx in dropped_train
                         ]
                         dropped_train_jitter = np.random.normal(
                             0, jitter_strength, len(dropped_train_positions)
@@ -853,8 +811,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                     dropped_val = np.setdiff1d(val_idx_no_us, val_idx_us)
                     if len(dropped_val) > 0:
                         dropped_val_positions = [
-                            np.where(time_order == idx)[0][0]
-                            for idx in dropped_val
+                            np.where(time_order == idx)[0][0] for idx in dropped_val
                         ]
                         dropped_val_jitter = np.random.normal(
                             0, jitter_strength, len(dropped_val_positions)
@@ -878,8 +835,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                     dropped_train = np.setdiff1d(train_idx_no_us, train_idx_us)
                     if len(dropped_train) > 0:
                         dropped_train_positions = [
-                            np.where(time_order == idx)[0][0]
-                            for idx in dropped_train
+                            np.where(time_order == idx)[0][0] for idx in dropped_train
                         ]
                         dropped_train_jitter = np.random.normal(
                             0, jitter_strength, len(dropped_train_positions)
@@ -927,7 +883,9 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                     # Color by class if y is provided
                     if y is not None:
                         train_colors = [
-                            stx.plt.color.PARAMS["RGBA_NORM"]["blue"] if y[idx] == 0 else stx.plt.color.PARAMS["RGBA_NORM"]["lightblue"]
+                            stx.plt.color.PARAMS["RGBA_NORM"]["blue"]
+                            if y[idx] == 0
+                            else stx.plt.color.PARAMS["RGBA_NORM"]["lightblue"]
                             for idx in train_idx
                         ]
                         ax.plot_scatter(
@@ -959,7 +917,9 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                     # Color by class if y is provided
                     if y is not None:
                         val_colors = [
-                            stx.plt.color.PARAMS["RGBA_NORM"]["yellow"] if y[idx] == 0 else stx.plt.color.PARAMS["RGBA_NORM"]["orange"]
+                            stx.plt.color.PARAMS["RGBA_NORM"]["yellow"]
+                            if y[idx] == 0
+                            else stx.plt.color.PARAMS["RGBA_NORM"]["orange"]
                             for idx in val_idx
                         ]
                         ax.plot_scatter(
@@ -991,7 +951,9 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                     # Color by class if y is provided
                     if y is not None:
                         test_colors = [
-                            stx.plt.color.PARAMS["RGBA_NORM"]["red"] if y[idx] == 0 else stx.plt.color.PARAMS["RGBA_NORM"]["brown"]
+                            stx.plt.color.PARAMS["RGBA_NORM"]["red"]
+                            if y[idx] == 0
+                            else stx.plt.color.PARAMS["RGBA_NORM"]["brown"]
                             for idx in test_idx
                         ]
                         ax.plot_scatter(
@@ -1021,14 +983,10 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
 
                 # Get actual timestamps for train and test indices
                 train_times = (
-                    timestamps[train_idx]
-                    if timestamps is not None
-                    else train_idx
+                    timestamps[train_idx] if timestamps is not None else train_idx
                 )
                 test_times = (
-                    timestamps[test_idx]
-                    if timestamps is not None
-                    else test_idx
+                    timestamps[test_idx] if timestamps is not None else test_idx
                 )
 
                 # Find temporal positions for scatter plot
@@ -1050,7 +1008,9 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                     # Color by class if y is provided
                     if y is not None:
                         train_colors = [
-                            stx.plt.color.PARAMS["RGBA_NORM"]["blue"] if y[idx] == 0 else stx.plt.color.PARAMS["RGBA_NORM"]["lightblue"]
+                            stx.plt.color.PARAMS["RGBA_NORM"]["blue"]
+                            if y[idx] == 0
+                            else stx.plt.color.PARAMS["RGBA_NORM"]["lightblue"]
                             for idx in train_idx
                         ]
                         ax.plot_scatter(
@@ -1082,7 +1042,9 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                     # Color by class if y is provided
                     if y is not None:
                         test_colors = [
-                            stx.plt.color.PARAMS["RGBA_NORM"]["red"] if y[idx] == 0 else stx.plt.color.PARAMS["RGBA_NORM"]["brown"]
+                            stx.plt.color.PARAMS["RGBA_NORM"]["red"]
+                            if y[idx] == 0
+                            else stx.plt.color.PARAMS["RGBA_NORM"]["brown"]
                             for idx in test_idx
                         ]
                         ax.plot_scatter(
@@ -1113,9 +1075,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
         ax.set_xlabel("Temporal Position (sorted by timestamp)")
         ax.set_ylabel("Fold")
         gap_text = f", Gap: {self.gap}" if self.gap > 0 else ""
-        val_text = (
-            f", Val ratio: {self.val_ratio:.1%}" if self.val_ratio > 0 else ""
-        )
+        val_text = f", Val ratio: {self.val_ratio:.1%}" if self.val_ratio > 0 else ""
         ax.set_title(
             f"Sliding Window Split Visualization ({split_type})\\n"
             f"Window: {self.window_size}, Step: {self.step_size}, Test: {self.test_size}{gap_text}{val_text}\\n"
@@ -1144,9 +1104,7 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
                 fold_info = f"Fold 0: Train n={len(train_idx)}, Val n={len(val_idx)}, Test n={len(test_idx)}"
             else:  # train, test
                 train_idx, test_idx = first_split
-                fold_info = (
-                    f"Fold 0: Train n={len(train_idx)}, Test n={len(test_idx)}"
-                )
+                fold_info = f"Fold 0: Train n={len(train_idx)}, Test n={len(test_idx)}"
 
             # Add legend with class information
             handles, labels = ax.get_legend_handles_labels()
@@ -1165,6 +1123,8 @@ class TimeSeriesSlidingWindowSplit(BaseCrossValidator):
 
 
 """Functions & Classes"""
+
+
 def main(args) -> int:
     """Demonstrate TimeSeriesSlidingWindowSplit functionality.
 
@@ -1203,9 +1163,7 @@ def main(args) -> int:
             )
 
         fig = splitter.plot_splits(X, y, timestamps)
-        stx.io.save(
-            fig, "./01_sliding_window_fixed.jpg", symlink_from_cwd=True
-        )
+        stx.io.save(fig, "./01_sliding_window_fixed.jpg", symlink_from_cwd=True)
         logger.info("")
 
         return splits
@@ -1240,9 +1198,7 @@ def main(args) -> int:
             )
 
         fig = splitter.plot_splits(X, y, timestamps)
-        stx.io.save(
-            fig, "./02_sliding_window_expanding.jpg", symlink_from_cwd=True
-        )
+        stx.io.save(fig, "./02_sliding_window_expanding.jpg", symlink_from_cwd=True)
         logger.info("")
 
         return splits
@@ -1256,9 +1212,7 @@ def main(args) -> int:
         logger.info("=" * 70)
         logger.info("DEMO 3: Fixed Window + Overlapping Tests")
         logger.info("=" * 70)
-        logger.info(
-            "Best for: Maximum evaluation points (like K-fold for training)"
-        )
+        logger.info("Best for: Maximum evaluation points (like K-fold for training)")
 
         splitter = TimeSeriesSlidingWindowSplit(
             window_size=args.window_size,
@@ -1273,14 +1227,10 @@ def main(args) -> int:
         logger.info(f"Generated {len(splits)} splits")
 
         for fold, (train_idx, test_idx) in enumerate(splits):
-            logger.info(
-                f"  Fold {fold}: Train={len(train_idx)}, Test={len(test_idx)}"
-            )
+            logger.info(f"  Fold {fold}: Train={len(train_idx)}, Test={len(test_idx)}")
 
         fig = splitter.plot_splits(X, y, timestamps)
-        stx.io.save(
-            fig, "./03_sliding_window_overlapping.jpg", symlink_from_cwd=True
-        )
+        stx.io.save(fig, "./03_sliding_window_overlapping.jpg", symlink_from_cwd=True)
         logger.info("")
 
         return splits
@@ -1309,15 +1259,13 @@ def main(args) -> int:
             undersample=False,
         )
 
-        splits_no_us = list(
-            splitter_no_undersample.split(X, y_imbalanced, timestamps)
-        )[:3]
+        splits_no_us = list(splitter_no_undersample.split(X, y_imbalanced, timestamps))[
+            :3
+        ]
         logger.info(f"WITHOUT undersampling: {len(splits_no_us)} splits")
         for fold, (train_idx, test_idx) in enumerate(splits_no_us):
             train_labels = y_imbalanced[train_idx]
-            train_unique, train_counts = np.unique(
-                train_labels, return_counts=True
-            )
+            train_unique, train_counts = np.unique(train_labels, return_counts=True)
             logger.info(
                 f"  Fold {fold}: Train size={len(train_idx)}, "
                 f"Class dist={dict(zip(train_unique, train_counts))}"
@@ -1333,15 +1281,11 @@ def main(args) -> int:
             random_state=42,
         )
 
-        splits_us = list(
-            splitter_undersample.split(X, y_imbalanced, timestamps)
-        )[:3]
+        splits_us = list(splitter_undersample.split(X, y_imbalanced, timestamps))[:3]
         logger.info(f"WITH undersampling: {len(splits_us)} splits")
         for fold, (train_idx, test_idx) in enumerate(splits_us):
             train_labels = y_imbalanced[train_idx]
-            train_unique, train_counts = np.unique(
-                train_labels, return_counts=True
-            )
+            train_unique, train_counts = np.unique(train_labels, return_counts=True)
             logger.info(
                 f"  Fold {fold}: Train size={len(train_idx)} (balanced!), "
                 f"Class dist={dict(zip(train_unique, train_counts))}"
@@ -1349,9 +1293,7 @@ def main(args) -> int:
 
         # Save visualization for undersampling
         fig = splitter_undersample.plot_splits(X, y_imbalanced, timestamps)
-        stx.io.save(
-            fig, "./04_sliding_window_undersample.jpg", symlink_from_cwd=True
-        )
+        stx.io.save(fig, "./04_sliding_window_undersample.jpg", symlink_from_cwd=True)
         logger.info("")
 
         return splits_us
@@ -1385,9 +1327,7 @@ def main(args) -> int:
             )
 
         fig = splitter.plot_splits(X, y, timestamps)
-        stx.io.save(
-            fig, "./05_sliding_window_validation.jpg", symlink_from_cwd=True
-        )
+        stx.io.save(fig, "./05_sliding_window_validation.jpg", symlink_from_cwd=True)
         logger.info("")
 
         return splits
@@ -1456,9 +1396,7 @@ def main(args) -> int:
 
         for fold, (train_idx, val_idx, test_idx) in enumerate(splits):
             train_labels = y_imbalanced[train_idx]
-            train_unique, train_counts = np.unique(
-                train_labels, return_counts=True
-            )
+            train_unique, train_counts = np.unique(train_labels, return_counts=True)
             logger.info(
                 f"  Fold {fold}: Train={len(train_idx)} (balanced!), Val={len(val_idx)}, Test={len(test_idx)}, "
                 f"Class dist={dict(zip(train_unique, train_counts))}"
@@ -1481,9 +1419,7 @@ def main(args) -> int:
         Shows all features working together.
         """
         logger.info("=" * 70)
-        logger.info(
-            "DEMO 8: Expanding + Undersampling + Validation (ALL OPTIONS)"
-        )
+        logger.info("DEMO 8: Expanding + Undersampling + Validation (ALL OPTIONS)")
         logger.info("=" * 70)
         logger.info("Best for: Comprehensive time series CV with all features")
 
@@ -1503,18 +1439,14 @@ def main(args) -> int:
 
         for fold, (train_idx, val_idx, test_idx) in enumerate(splits):
             train_labels = y_imbalanced[train_idx]
-            train_unique, train_counts = np.unique(
-                train_labels, return_counts=True
-            )
+            train_unique, train_counts = np.unique(train_labels, return_counts=True)
             logger.info(
                 f"  Fold {fold}: Train={len(train_idx)} (growing & balanced!), Val={len(val_idx)}, Test={len(test_idx)}, "
                 f"Class dist={dict(zip(train_unique, train_counts))}"
             )
 
         fig = splitter.plot_splits(X, y_imbalanced, timestamps)
-        stx.io.save(
-            fig, "./08_sliding_window_all_options.jpg", symlink_from_cwd=True
-        )
+        stx.io.save(fig, "./08_sliding_window_all_options.jpg", symlink_from_cwd=True)
         logger.info("")
 
         return splits
@@ -1602,21 +1534,15 @@ def main(args) -> int:
     # Create imbalanced labels (80% class 0, 20% class 1)
     y_imbalanced = np.zeros(n_samples, dtype=int)
     n_minority = int(n_samples * 0.2)
-    minority_indices = np.random.choice(
-        n_samples, size=n_minority, replace=False
-    )
+    minority_indices = np.random.choice(n_samples, size=n_minority, replace=False)
     y_imbalanced[minority_indices] = 1
 
-    logger.info(
-        f"Generated test data: {n_samples} samples, {X.shape[1]} features"
-    )
+    logger.info(f"Generated test data: {n_samples} samples, {X.shape[1]} features")
     logger.info("")
 
     # Run demos
     splits_fixed = demo_01_fixed_window_non_overlapping_tests(X, y, timestamps)
-    splits_expanding = demo_02_expanding_window_non_overlapping_tests(
-        X, y, timestamps
-    )
+    splits_expanding = demo_02_expanding_window_non_overlapping_tests(X, y, timestamps)
     splits_overlap = demo_03_fixed_window_overlapping_tests(X, y, timestamps)
     splits_undersample = demo_04_undersample_imbalanced_data(
         X, y_imbalanced, timestamps
@@ -1626,9 +1552,7 @@ def main(args) -> int:
     splits_undersample_val = demo_07_undersample_with_validation(
         X, y_imbalanced, timestamps
     )
-    splits_all_options = demo_08_all_options_combined(
-        X, y_imbalanced, timestamps
-    )
+    splits_all_options = demo_08_all_options_combined(X, y_imbalanced, timestamps)
 
     # Print summary
     print_summary(