wavedl 1.6.3__py3-none-any.whl → 1.7.0__py3-none-any.whl

wavedl/utils/cross_validation.py

@@ -36,7 +36,9 @@ from torch.utils.data import DataLoader
 class CVDataset(torch.utils.data.Dataset):
     """Simple in-memory dataset for cross-validation."""
 
-    def __init__(self, X: np.ndarray, y: np.ndarray, expected_spatial_ndim: int = None):
+    def __init__(
+        self, X: np.ndarray, y: np.ndarray, expected_spatial_ndim: int | None = None
+    ):
         """
         Initialize CV dataset with explicit channel dimension handling.
 
@@ -51,6 +53,11 @@ class CVDataset(torch.utils.data.Dataset):
             - If X.ndim == expected_spatial_ndim + 1: Add channel dim (N, *spatial) -> (N, 1, *spatial)
             - If X.ndim == expected_spatial_ndim + 2: Already has channel (N, C, *spatial)
             - If expected_spatial_ndim is None: Use legacy ndim-based inference
+
+        Warning:
+            Legacy mode (expected_spatial_ndim=None) may misinterpret multichannel
+            3D data as single-channel 4D data. Always pass expected_spatial_ndim
+            explicitly for 3D volumes with >1 channel.
         """
         if expected_spatial_ndim is not None:
             # Explicit mode: use expected_spatial_ndim to determine if channel exists
@@ -100,6 +107,7 @@ def train_fold(
     device: torch.device,
     epochs: int,
     patience: int,
+    grad_clip: float,
     scaler: StandardScaler,
     logger: logging.Logger,
 ) -> dict[str, Any]:
@@ -147,7 +155,8 @@ def train_fold(
             pred = model(x)
             loss = criterion(pred, y)
             loss.backward()
-            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            if grad_clip > 0:
+                torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
             optimizer.step()
 
             # Per-batch LR scheduling (OneCycleLR)
@@ -289,6 +298,7 @@ def run_cross_validation(
     output_dir: str = "./cv_results",
     workers: int = 4,
     seed: int = 2025,
+    grad_clip: float = 1.0,
     logger: logging.Logger | None = None,
 ) -> dict[str, Any]:
     """
@@ -330,8 +340,10 @@ def run_cross_validation(
         )
         logger = logging.getLogger("CV-Trainer")
 
-    # Set seeds
-    np.random.seed(seed)
+    # Set seeds for reproducibility
+    # Note: sklearn KFold uses random_state parameter directly, not global numpy RNG
+    rng = np.random.default_rng(seed)  # Local RNG for any numpy operations
+    _ = rng  # Silence unused variable warning (available for future use)
     torch.manual_seed(seed)
     if torch.cuda.is_available():
         torch.cuda.manual_seed_all(seed)
@@ -444,6 +456,7 @@ def run_cross_validation(
             device=device,
             epochs=epochs,
             patience=patience,
+            grad_clip=grad_clip,
             scaler=scaler,
             logger=logger,
         )

wavedl/utils/data.py

@@ -798,6 +798,128 @@ def load_outputs_only(path: str, format: str = "auto") -> np.ndarray:
     return source.load_outputs_only(path)
 
 
+def _load_npz_for_test(
+    path: str,
+    input_keys: list[str],
+    output_keys: list[str],
+    explicit_input_key: str | None,
+    explicit_output_key: str | None,
+) -> tuple[np.ndarray, np.ndarray | None]:
+    """Load NPZ file for test/inference with key validation."""
+    with np.load(path, allow_pickle=False) as probe:
+        keys = list(probe.keys())
+
+    inp_key = DataSource._find_key(keys, input_keys)
+    out_key = DataSource._find_key(keys, output_keys)
+
+    # Strict validation for explicit keys
+    if explicit_input_key is not None and explicit_input_key not in keys:
+        raise KeyError(
+            f"Explicit --input_key '{explicit_input_key}' not found. Available: {keys}"
+        )
+    if inp_key is None:
+        raise KeyError(f"Input key not found. Tried: {input_keys}. Found: {keys}")
+    if explicit_output_key is not None and explicit_output_key not in keys:
+        raise KeyError(
+            f"Explicit --output_key '{explicit_output_key}' not found. Available: {keys}"
+        )
+
+    data = NPZSource._load_and_copy(path, [inp_key] + ([out_key] if out_key else []))
+    inp = data[inp_key]
+    if inp.dtype == object:
+        inp = np.array([x.toarray() if hasattr(x, "toarray") else x for x in inp])
+    outp = data[out_key] if out_key else None
+    return inp, outp
+
+
+def _load_hdf5_for_test(
+    path: str,
+    input_keys: list[str],
+    output_keys: list[str],
+    explicit_input_key: str | None,
+    explicit_output_key: str | None,
+) -> tuple[np.ndarray, np.ndarray | None]:
+    """Load HDF5 file for test/inference with key validation and OOM guard."""
+    with h5py.File(path, "r") as f:
+        keys = list(f.keys())
+        inp_key = DataSource._find_key(keys, input_keys)
+        out_key = DataSource._find_key(keys, output_keys)
+
+        # Strict validation
+        if explicit_input_key is not None and explicit_input_key not in keys:
+            raise KeyError(
+                f"Explicit --input_key '{explicit_input_key}' not found. Available: {keys}"
+            )
+        if inp_key is None:
+            raise KeyError(f"Input key not found. Tried: {input_keys}. Found: {keys}")
+        if explicit_output_key is not None and explicit_output_key not in keys:
+            raise KeyError(
+                f"Explicit --output_key '{explicit_output_key}' not found. Available: {keys}"
+            )
+
+        # OOM guard
+        n_samples = f[inp_key].shape[0]
+        if n_samples > 100000:
+            raise ValueError(
+                f"Dataset has {n_samples:,} samples. load_test_data() loads "
+                f"everything into RAM which may cause OOM. For large inference "
+                f"sets, use a DataLoader with HDF5Source.load_mmap() instead."
+            )
+
+        inp = f[inp_key][:]
+        outp = f[out_key][:] if out_key else None
+    return inp, outp
+
+
+def _load_mat_for_test(
+    path: str,
+    input_keys: list[str],
+    output_keys: list[str],
+    explicit_input_key: str | None,
+    explicit_output_key: str | None,
+) -> tuple[np.ndarray, np.ndarray | None]:
+    """Load MAT v7.3 file for test/inference with sparse support."""
+    mat_source = MATSource()
+    with h5py.File(path, "r") as f:
+        keys = list(f.keys())
+        inp_key = DataSource._find_key(keys, input_keys)
+        out_key = DataSource._find_key(keys, output_keys)
+
+        # Strict validation
+        if explicit_input_key is not None and explicit_input_key not in keys:
+            raise KeyError(
+                f"Explicit --input_key '{explicit_input_key}' not found. Available: {keys}"
+            )
+        if inp_key is None:
+            raise KeyError(f"Input key not found. Tried: {input_keys}. Found: {keys}")
+        if explicit_output_key is not None and explicit_output_key not in keys:
+            raise KeyError(
+                f"Explicit --output_key '{explicit_output_key}' not found. Available: {keys}"
+            )
+
+        # OOM guard
+        n_samples = f[inp_key].shape[-1]  # MAT is transposed
+        if n_samples > 100000:
+            raise ValueError(
+                f"Dataset has {n_samples:,} samples. load_test_data() loads "
+                f"everything into RAM which may cause OOM. For large inference "
+                f"sets, use a DataLoader with MATSource.load_mmap() instead."
+            )
+
+        inp = mat_source._load_dataset(f, inp_key)
+        outp = None
+        if out_key:
+            outp = mat_source._load_dataset(f, out_key)
+            # Handle MATLAB transpose
+            num_samples = inp.shape[0]
+            if outp.ndim == 2:
+                if (outp.shape[0] == 1 and outp.shape[1] == num_samples) or (
+                    outp.shape[1] == 1 and outp.shape[0] != num_samples
+                ):
+                    outp = outp.T
+    return inp, outp
+
+
 def load_test_data(
     path: str,
     format: str = "auto",
@@ -865,112 +987,17 @@ def load_test_data(
     # We detect keys first to ensure input_test/output_test are used when present
     try:
         if format == "npz":
-            with np.load(path, allow_pickle=False) as probe:
-                keys = list(probe.keys())
-            inp_key = DataSource._find_key(keys, custom_input_keys)
-            out_key = DataSource._find_key(keys, custom_output_keys)
-            # Strict validation: if user explicitly specified input_key, it must exist exactly
-            if input_key is not None and input_key not in keys:
-                raise KeyError(
-                    f"Explicit --input_key '{input_key}' not found. "
-                    f"Available keys: {keys}"
-                )
-            if inp_key is None:
-                raise KeyError(
-                    f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
-                )
-            # Strict validation: if user explicitly specified output_key, it must exist exactly
-            if output_key is not None and output_key not in keys:
-                raise KeyError(
-                    f"Explicit --output_key '{output_key}' not found. "
-                    f"Available keys: {keys}"
-                )
-            data = NPZSource._load_and_copy(
-                path, [inp_key] + ([out_key] if out_key else [])
+            inp, outp = _load_npz_for_test(
+                path, custom_input_keys, custom_output_keys, input_key, output_key
             )
-            inp = data[inp_key]
-            if inp.dtype == object:
-                inp = np.array(
-                    [x.toarray() if hasattr(x, "toarray") else x for x in inp]
-                )
-            outp = data[out_key] if out_key else None
         elif format == "hdf5":
-            with h5py.File(path, "r") as f:
-                keys = list(f.keys())
-                inp_key = DataSource._find_key(keys, custom_input_keys)
-                out_key = DataSource._find_key(keys, custom_output_keys)
-                # Strict validation: if user explicitly specified input_key, it must exist exactly
-                if input_key is not None and input_key not in keys:
-                    raise KeyError(
-                        f"Explicit --input_key '{input_key}' not found. "
-                        f"Available keys: {keys}"
-                    )
-                if inp_key is None:
-                    raise KeyError(
-                        f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
-                    )
-                # Strict validation: if user explicitly specified output_key, it must exist exactly
-                if output_key is not None and output_key not in keys:
-                    raise KeyError(
-                        f"Explicit --output_key '{output_key}' not found. "
-                        f"Available keys: {keys}"
-                    )
-                # OOM guard: warn if dataset is very large
-                n_samples = f[inp_key].shape[0]
-                if n_samples > 100000:
-                    raise ValueError(
-                        f"Dataset has {n_samples:,} samples. load_test_data() loads "
-                        f"everything into RAM which may cause OOM. For large inference "
-                        f"sets, use a DataLoader with HDF5Source.load_mmap() instead."
-                    )
-                inp = f[inp_key][:]
-                outp = f[out_key][:] if out_key else None
+            inp, outp = _load_hdf5_for_test(
+                path, custom_input_keys, custom_output_keys, input_key, output_key
+            )
         elif format == "mat":
-            mat_source = MATSource()
-            with h5py.File(path, "r") as f:
-                keys = list(f.keys())
-                inp_key = DataSource._find_key(keys, custom_input_keys)
-                out_key = DataSource._find_key(keys, custom_output_keys)
-                # Strict validation: if user explicitly specified input_key, it must exist exactly
-                if input_key is not None and input_key not in keys:
-                    raise KeyError(
-                        f"Explicit --input_key '{input_key}' not found. "
-                        f"Available keys: {keys}"
-                    )
-                if inp_key is None:
-                    raise KeyError(
-                        f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
-                    )
-                # Strict validation: if user explicitly specified output_key, it must exist exactly
-                if output_key is not None and output_key not in keys:
-                    raise KeyError(
-                        f"Explicit --output_key '{output_key}' not found. "
-                        f"Available keys: {keys}"
-                    )
-                # OOM guard: warn if dataset is very large (MAT is transposed)
-                n_samples = f[inp_key].shape[-1]
-                if n_samples > 100000:
-                    raise ValueError(
-                        f"Dataset has {n_samples:,} samples. load_test_data() loads "
-                        f"everything into RAM which may cause OOM. For large inference "
-                        f"sets, use a DataLoader with MATSource.load_mmap() instead."
-                    )
-                inp = mat_source._load_dataset(f, inp_key)
-                if out_key:
-                    outp = mat_source._load_dataset(f, out_key)
-                    # Handle transposed outputs from MATLAB
-                    # Case 1: (1, N) - N samples with 1 target → transpose to (N, 1)
-                    # Case 2: (T, 1) - 1 sample with T targets → transpose to (1, T)
-                    num_samples = inp.shape[0]
-                    if outp.ndim == 2:
-                        if outp.shape[0] == 1 and outp.shape[1] == num_samples:
-                            # 1D vector: (1, N) → (N, 1)
-                            outp = outp.T
-                        elif outp.shape[1] == 1 and outp.shape[0] != num_samples:
-                            # Single sample with multiple targets: (T, 1) → (1, T)
-                            outp = outp.T
-                else:
-                    outp = None
+            inp, outp = _load_mat_for_test(
+                path, custom_input_keys, custom_output_keys, input_key, output_key
+            )
         else:
             # Fallback to default source.load() for unknown formats
             inp, outp = source.load(path)
@@ -993,80 +1020,19 @@ def load_test_data(
             ) from e
 
         # Legitimate fallback: no explicit keys, outputs just not present
+        # Re-call helpers with None for explicit keys (validation already done above)
         if format == "npz":
-            # First pass to find keys
-            with np.load(path, allow_pickle=False) as probe:
-                keys = list(probe.keys())
-            inp_key = DataSource._find_key(keys, custom_input_keys)
-            if inp_key is None:
-                raise KeyError(
-                    f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
-                )
-            out_key = DataSource._find_key(keys, custom_output_keys)
-            keys_to_probe = [inp_key] + ([out_key] if out_key else [])
-            data = NPZSource._load_and_copy(path, keys_to_probe)
-            inp = data[inp_key]
-            if inp.dtype == object:
-                inp = np.array(
-                    [x.toarray() if hasattr(x, "toarray") else x for x in inp]
-                )
-            outp = data[out_key] if out_key else None
+            inp, outp = _load_npz_for_test(
+                path, custom_input_keys, custom_output_keys, None, None
+            )
         elif format == "hdf5":
-            # HDF5: input-only loading for inference
-            with h5py.File(path, "r") as f:
-                keys = list(f.keys())
-                inp_key = DataSource._find_key(keys, custom_input_keys)
-                if inp_key is None:
-                    raise KeyError(
-                        f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
-                    )
-                # Check size - load_test_data is eager, large files should use DataLoader
-                n_samples = f[inp_key].shape[0]
-                if n_samples > 100000:
-                    raise ValueError(
-                        f"Dataset has {n_samples:,} samples. load_test_data() loads "
-                        f"everything into RAM which may cause OOM. For large inference "
-                        f"sets, use a DataLoader with HDF5Source.load_mmap() instead."
-                    )
-                inp = f[inp_key][:]
-                out_key = DataSource._find_key(keys, custom_output_keys)
-                outp = f[out_key][:] if out_key else None
+            inp, outp = _load_hdf5_for_test(
+                path, custom_input_keys, custom_output_keys, None, None
+            )
         elif format == "mat":
-            # MAT v7.3: input-only loading with proper sparse handling
-            mat_source = MATSource()
-            with h5py.File(path, "r") as f:
-                keys = list(f.keys())
-                inp_key = DataSource._find_key(keys, custom_input_keys)
-                if inp_key is None:
-                    raise KeyError(
-                        f"Input key not found. Tried: {custom_input_keys}. Found: {keys}"
-                    )
-                # Check size - load_test_data is eager, large files should use DataLoader
-                n_samples = f[inp_key].shape[-1]  # MAT is transposed
-                if n_samples > 100000:
-                    raise ValueError(
-                        f"Dataset has {n_samples:,} samples. load_test_data() loads "
-                        f"everything into RAM which may cause OOM. For large inference "
-                        f"sets, use a DataLoader with MATSource.load_mmap() instead."
-                    )
-                # Use _load_dataset for sparse support and proper transpose
-                inp = mat_source._load_dataset(f, inp_key)
-                out_key = DataSource._find_key(keys, custom_output_keys)
-                if out_key:
-                    outp = mat_source._load_dataset(f, out_key)
-                    # Handle transposed outputs from MATLAB
-                    # Case 1: (1, N) - N samples with 1 target → transpose to (N, 1)
-                    # Case 2: (T, 1) - 1 sample with T targets → transpose to (1, T)
-                    num_samples = inp.shape[0]
-                    if outp.ndim == 2:
-                        if outp.shape[0] == 1 and outp.shape[1] == num_samples:
-                            # 1D vector: (1, N) → (N, 1)
-                            outp = outp.T
-                        elif outp.shape[1] == 1 and outp.shape[0] != num_samples:
-                            # Single sample with multiple targets: (T, 1) → (1, T)
-                            outp = outp.T
-                else:
-                    outp = None
+            inp, outp = _load_mat_for_test(
+                path, custom_input_keys, custom_output_keys, None, None
+            )
         else:
             raise
 

wavedl/utils/metrics.py

@@ -106,8 +106,20 @@ def configure_matplotlib_style():
     )
 
 
-# Apply style on import
-configure_matplotlib_style()
+# Lazy style initialization flag
+_style_configured = False
+
+
+def _ensure_style_configured():
+    """Apply matplotlib style on first use (lazy initialization).
+
+    This avoids modifying global plt.rcParams at import time, which could
+    unexpectedly override user configurations.
+    """
+    global _style_configured
+    if not _style_configured:
+        configure_matplotlib_style()
+        _style_configured = True
 
 
 # ==============================================================================
@@ -115,11 +127,14 @@ configure_matplotlib_style()
 # ==============================================================================
 class MetricTracker:
     """
-    Tracks running averages of metrics with thread-safe accumulation.
+    Tracks running averages of metrics during training.
 
     Useful for tracking loss, accuracy, or any scalar metric across batches.
     Handles division-by-zero safely by returning 0.0 when count is zero.
 
+    Note:
+        Not thread-safe. Intended for single-threaded use within training loops.
+
     Attributes:
         val: Most recent value
         avg: Running average
@@ -341,6 +356,7 @@ def plot_scientific_scatter(
     Returns:
         Matplotlib Figure object (can be saved or logged to WandB)
     """
+    _ensure_style_configured()
     y_true, y_pred, param_names, num_params = _prepare_plot_data(
         y_true, y_pred, param_names, max_samples
     )
@@ -415,6 +431,7 @@ def plot_error_histogram(
     Returns:
         Matplotlib Figure object
     """
+    _ensure_style_configured()
     y_true, y_pred, param_names, num_params = _prepare_plot_data(
         y_true, y_pred, param_names
     )
@@ -485,6 +502,7 @@ def plot_residuals(
     Returns:
         Matplotlib Figure object
     """
+    _ensure_style_configured()
     y_true, y_pred, param_names, num_params = _prepare_plot_data(
         y_true, y_pred, param_names, max_samples
     )
@@ -552,6 +570,7 @@ def create_training_curves(
     Returns:
         Matplotlib Figure object
     """
+    _ensure_style_configured()
     epochs = [h.get("epoch", i + 1) for i, h in enumerate(history)]
 
     fig, ax1 = plt.subplots(figsize=(FIGURE_WIDTH_INCH * 0.7, FIGURE_WIDTH_INCH * 0.4))
@@ -605,8 +624,8 @@ def create_training_curves(
         if not valid_data:
             return
         vmin, vmax = min(valid_data), max(valid_data)
-        # Get decade range that covers data (ceil for min to avoid going too low)
-        log_min = int(np.ceil(np.log10(vmin)))
+        # Get decade range that covers data (floor for min to include lowest data)
+        log_min = int(np.floor(np.log10(vmin)))
         log_max = int(np.ceil(np.log10(vmax)))
         # Generate ticks at each power of 10
         ticks = [10.0**i for i in range(log_min, log_max + 1)]
@@ -691,6 +710,7 @@ def plot_bland_altman(
     Returns:
         Matplotlib Figure object
     """
+    _ensure_style_configured()
     y_true, y_pred, param_names, num_params = _prepare_plot_data(
         y_true, y_pred, param_names, max_samples
     )
@@ -764,6 +784,7 @@ def plot_qq(
     Returns:
         Matplotlib Figure object
     """
+    _ensure_style_configured()
     from scipy import stats
 
     num_params = y_true.shape[1] if y_true.ndim > 1 else 1

wavedl/utils/schedulers.py

@@ -76,7 +76,7 @@ def get_scheduler(
     # Step/MultiStep parameters
     step_size: int = 30,
     milestones: list[int] | None = None,
-    gamma: float = 0.1,
+    gamma: float = 0.99,
     # Linear warmup parameters
     warmup_epochs: int = 5,
     start_factor: float = 0.1,
@@ -100,7 +100,7 @@ def get_scheduler(
         pct_start: Percentage of cycle spent increasing LR (OneCycleLR)
         step_size: Period for StepLR
         milestones: Epochs to decay LR for MultiStepLR
-        gamma: Decay factor for step/multistep/exponential
+        gamma: Decay factor (0.1 for step/multistep, 0.99 for exponential)
         warmup_epochs: Number of warmup epochs for linear_warmup
         start_factor: Starting LR factor for warmup (LR * start_factor)
         **kwargs: Additional arguments passed to scheduler

{wavedl-1.6.3.dist-info → wavedl-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: wavedl
-Version: 1.6.3
+Version: 1.7.0
 Summary: A Scalable Deep Learning Framework for Wave-Based Inverse Problems
 Author: Ductho Le
 License: MIT
@@ -907,18 +907,24 @@ Automatically find the best training configuration using [Optuna](https://optuna
 **Run HPO:**
 
 ```bash
-# Basic HPO (auto-detects GPUs for parallel trials)
-wavedl-hpo --data_path train.npz --models cnn --n_trials 100
+# Basic HPO (50 trials, auto-detects GPUs)
+wavedl-hpo --data_path train.npz --n_trials 50
 
-# Search multiple models
-wavedl-hpo --data_path train.npz --models cnn resnet18 efficientnet_b0 --n_trials 200
+# Quick search (minimal search space, fastest)
+wavedl-hpo --data_path train.npz --n_trials 30 --quick
 
-# Quick mode (fewer parameters, faster)
-wavedl-hpo --data_path train.npz --models cnn --n_trials 50 --quick
+# Medium search (balanced between quick and full)
+wavedl-hpo --data_path train.npz --n_trials 50 --medium
+
+# Full search with specific models
+wavedl-hpo --data_path train.npz --n_trials 100 --models cnn resnet18 efficientnet_b0
+
+# In-process mode (enables pruning, faster, single-GPU)
+wavedl-hpo --data_path train.npz --n_trials 50 --inprocess
 ```
 
 > [!TIP]
-> **Auto GPU Detection**: HPO automatically detects available GPUs and runs one trial per GPU in parallel. On a 4-GPU system, 4 trials run simultaneously. Use `--n_jobs 1` to force serial execution.
+> **GPU Detection**: HPO auto-detects GPUs and runs one trial per GPU in parallel. Use `--inprocess` for single-GPU with pruning support (early stopping of bad trials).
 
 **Train with best parameters**
 
@@ -940,10 +946,23 @@ wavedl-train --data_path train.npz --model cnn --lr 3.2e-4 --batch_size 128 ...
 | Learning rate | 1e-5 → 1e-2 | (always searched) |
 | Batch size | 16, 32, 64, 128 | (always searched) |
 
-**Quick Mode** (`--quick`):
-- Uses minimal defaults: cnn + adamw + plateau + mse
-- Faster for testing your setup before running full search
-- You can still override any option with the flags above
+**Search Presets:**
+
+| Mode | Models | Optimizers | Schedulers | Use Case |
+|------|--------|------------|------------|----------|
+| Full (default) | cnn, resnet18, resnet34 | all 6 | all 8 | Production search |
+| `--medium` | cnn, resnet18 | adamw, adam, sgd | plateau, cosine, onecycle | Balanced exploration |
+| `--quick` | cnn | adamw | plateau | Fast validation |
+
+**Execution Modes:**
+
+| Mode | Flag | Pruning | GPU Memory | Best For |
+|------|------|---------|------------|----------|
+| Subprocess (default) | — | ❌ No | Isolated | Multi-GPU parallel trials |
+| In-process | `--inprocess` | ✅ Yes | Shared | Single-GPU with early stopping |
+
+> [!TIP]
+> Use `--inprocess` when running single-GPU trials. It enables MedianPruner to stop unpromising trials early, reducing total search time.
 
 ---
 
@@ -954,7 +973,9 @@ wavedl-train --data_path train.npz --model cnn --lr 3.2e-4 --batch_size 128 ...
 | `--data_path` | (required) | Training data file |
 | `--models` | 3 defaults | Models to search (specify any number) |
 | `--n_trials` | `50` | Number of trials to run |
-| `--quick` | `False` | Use minimal defaults (faster) |
+| `--quick` | `False` | Quick mode: minimal search space |
+| `--medium` | `False` | Medium mode: balanced search space |
+| `--inprocess` | `False` | Run trials in-process (enables pruning) |
 | `--optimizers` | all 6 | Optimizers to search |
 | `--schedulers` | all 8 | Schedulers to search |
 | `--losses` | all 6 | Losses to search |
@@ -963,7 +984,7 @@ wavedl-train --data_path train.npz --model cnn --lr 3.2e-4 --batch_size 128 ...
 | `--output` | `hpo_results.json` | Output file |
 
 
-> See [Available Models](#available-models) for all 38 architectures you can search.
+> See [Available Models](#available-models) for all 69 architectures you can search.
 
 </details>
 

wavedl-1.7.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+wavedl/__init__.py,sha256=Ol1M5mok2rnnUKDPBZLQDBDwKn7_LV9iTxds5obDeJk,1177
+wavedl/hpo.py,sha256=TyEWubL-adQJyRmSv1M1SnJvH7_vTlXJATI1ElxXVUU,18991
+wavedl/launcher.py,sha256=_CFlgpKgHrtZebl1yQbJZJEcob06Y9-fqnRYzwW7UJQ,11776
+wavedl/test.py,sha256=_6i6F1KkO24cC0RtvxcwAGxDUbU6VV12efDWFGojkeE,38466
+wavedl/train.py,sha256=U0-hHo4wba1dhZ2jjaCFURiS6aGHuPDGz0zPwPm2Kc0,72722
+wavedl/models/__init__.py,sha256=hyR__h_D8PsUQCBSM5tj94yYK00uG8ABjEmj_RR8SGE,5719
+wavedl/models/_pretrained_utils.py,sha256=br--ZrgqndYCO_iAeQOvUDg6ZxzGDyLZFeWu1Qj_DrI,14756
+wavedl/models/_template.py,sha256=nEixVS8e82Tud08Uk8jkXtriGhk_WFbqSaGDq_Mj4ak,4684
+wavedl/models/base.py,sha256=bDoHYFli-aR8amcFYXbF98QYaKSCEwZWpvOhN21ODro,9075
+wavedl/models/caformer.py,sha256=ufPM-HzQ-qUZcXgnOulurY6jBUlMUzokC01whtPeVMg,7922
+wavedl/models/cnn.py,sha256=dOmCrHGXd8Md8ixbJ_-An9t80tm36sVY84je2EDmnZA,8256
+wavedl/models/convnext.py,sha256=GoLId2HClsOksuL3XLscEIytrmOBPGhO6UhGn04yDp4,13354
+wavedl/models/convnext_v2.py,sha256=jPPXTZbQQ8zE9yGVWTNUaI5g1d0xIxBjrLuUHUKc5mM,14349
+wavedl/models/densenet.py,sha256=V_caGd0wsG_Q3Q38I4MEgYmU0v4j8mDyvv7Rn3Bk7Ac,12667
+wavedl/models/efficientnet.py,sha256=HWfhqSX57lC5Xug5TrQ3r-uFqkksoIKjmQ5Zr5njkEA,8264
+wavedl/models/efficientnetv2.py,sha256=hVSnVId8T1rjqaKlckLqWFwvo2J-qASX7o9lMbXbP-s,10947
+wavedl/models/efficientvit.py,sha256=KqFoZq9YHBMnTue6aMdPKgBOMczeBPryY_F6ip0hoEI,11630
+wavedl/models/fastvit.py,sha256=S0SF0iC-9ZJrP-9YUTLPhMJMV-W9r2--V3hVAmSSVKI,7083
+wavedl/models/mamba.py,sha256=2mqBxUKCLJNkRc87QzpsOj6hKzrEh5tchGSyYZCSUcQ,20031
+wavedl/models/maxvit.py,sha256=I6TFGrLRcyMU-nU7u5VhOaXZWWdwmNJwHsMqbJh_g_o,7548
+wavedl/models/mobilenetv3.py,sha256=LZxCg599kGP6-XI_l3PpT8jzh4oTAdWH3Y7GH097o28,10242
+wavedl/models/registry.py,sha256=InYAXX2xbRvsFDFnYUPCptJh0F9lHlFPN77A9kqHRT0,2980
+wavedl/models/regnet.py,sha256=6Yjo2wZzdjK8VpOMagbCrHqmsfRmGkuiURmc-MesYvA,13777
+wavedl/models/resnet.py,sha256=3i4zfE15qF4cd0qbTKX-Wdy2Kd0f4mLcdd316FAcVCo,16720
+wavedl/models/resnet3d.py,sha256=NS6UBmvITO3NbdBNfe39bxViFqrIgeSXBnDgYi8QsC8,9247
+wavedl/models/swin.py,sha256=39Gwn5hNEw3-tndc8qFFzV-VZ7pJMMKey2oZONAZ8MU,14980
+wavedl/models/tcn.py,sha256=XzojpuMFG4lu_0oQHbQnkLAb7AnW-D7_6KoBlQDPLnQ,12367
+wavedl/models/unet.py,sha256=oi7eBONSe0ALpJKsYda3jRGwu-LuSiFgNdURebnGGt0,7712
+wavedl/models/unireplknet.py,sha256=sbiYcc2NeB0-_VAmeoe9Vi5hQzhYz03knG7o2Qk0WYE,14634
+wavedl/models/vit.py,sha256=o-zWT2GBCTs9vD3jUFwlcwxK53XqEn_x4iPaRuEQe10,15219
+wavedl/utils/__init__.py,sha256=CYqD3Bcwcub2mSrW05x8wvd2n1Co_3N9ajyKPyBswjo,4887
+wavedl/utils/config.py,sha256=yAKuuhM-oxvHFXomkkek4IGihsVO5yZxc4b2noQ1amE,10523
+wavedl/utils/constraints.py,sha256=V9Gyi8-uIMbLUWb2cOaHZD0SliWLxVrHZHFyo4HWK7g,18031
+wavedl/utils/cross_validation.py,sha256=evp8EsHGJcxMHpfRdFSParDltUTyMhKQxUkcn5-osI4,18556
+wavedl/utils/data.py,sha256=f-LLIiiv74iiKrR8TQ9oeKODF29_jzeUUp4iMBuj_H4,60875
+wavedl/utils/distributed.py,sha256=7wQ3mRjkp_xjPSxDWMnBf5dSkAGUaTzntxbz0BhC5v0,4145
+wavedl/utils/losses.py,sha256=KWpU5S5noFzp3bLbcH9RNpkFPajy6fyTIh5cNjI-BYA,7038
+wavedl/utils/metrics.py,sha256=tLzKG2zINyXit-KvYZSJg-1nG6rST54GH6k4ALonToU,40935
+wavedl/utils/optimizers.py,sha256=ZoETDSOK1fWUT2dx69PyYebeM8Vcqf9zOIKUERWk5HY,6107
+wavedl/utils/schedulers.py,sha256=_aFTQ8kuvdZIxOoXPHQRu_N9XBuTVSjU6dmBbzH430o,7425
+wavedl-1.7.0.dist-info/LICENSE,sha256=cEUCvcvH-9BT9Y-CNGY__PwWONCKu9zsoIqWA-NeHJ4,1066
+wavedl-1.7.0.dist-info/METADATA,sha256=f5UMARudJtBdt5Pu3E18Rfk2sD4h77A2mt8Mh8_cJk4,48527
+wavedl-1.7.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+wavedl-1.7.0.dist-info/entry_points.txt,sha256=NuAvdiG93EYYpqv-_1wf6PN0WqBfABanDKalNKe2GOs,148
+wavedl-1.7.0.dist-info/top_level.txt,sha256=ccneUt3D5Qzbh3bsBSSrq9bqrhGiogcWKY24ZC4Q6Xw,7
+wavedl-1.7.0.dist-info/RECORD,,