halib 0.1.99__py3-none-any.whl → 0.2.21__py3-none-any.whl

halib/exp/core/base_config.py

@@ -0,0 +1,167 @@
+import os
+from rich.pretty import pprint
+from abc import ABC, abstractmethod
+from typing import List, Optional, TypeVar, Generic
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from dataclass_wizard import YAMLWizard
+
+
+class NamedCfg(ABC):
+    """
+    Base class for named configurations.
+    All configurations should have a name.
+    """
+
+    @abstractmethod
+    def get_name(self):
+        """
+        Get the name of the configuration.
+        This method should be implemented in subclasses.
+        """
+        pass
+
+
+@dataclass
+class AutoNamedCfg(YAMLWizard, NamedCfg):
+    """
+    Mixin that automatically implements get_name() by returning self.name.
+    Classes using this MUST have a 'name' field.
+    """
+
+    name: Optional[str] = None
+
+    def get_name(self):
+        return self.name
+
+    def __post_init__(self):
+        # Enforce the "MUST" rule here
+        if self.name is None:
+            # We allow None during initial load, but it must be set before usage
+            # or handled by the loader.
+            pass
+
+
+T = TypeVar("T", bound=AutoNamedCfg)
+
+
+class BaseSelectorCfg(Generic[T]):
+    """
+    Base class to handle the logic of selecting an item from a list by name.
+    """
+
+    def _resolve_selection(self, items: List[T], selected_name: str, context: str) -> T:
+        if selected_name is None:
+            raise ValueError(f"No {context} selected in the configuration.")
+
+        # Create a lookup dict for O(1) access, or just iterate if list is short
+        for item in items:
+            if item.name == selected_name:
+                return item
+
+        raise ValueError(
+            f"{context.capitalize()} '{selected_name}' not found in the configuration list."
+        )
+
+
+class ExpBaseCfg(ABC, YAMLWizard):
+    """
+    Base class for configuration objects.
+    What a cfg class must have:
+    1 - a dataset cfg
+    2 - a metric cfg
+    3 - a method cfg
+    """
+
+    cfg_name: Optional[str] = None
+
+    # Save to yaml fil
+    def save_to_outdir(
+        self, filename: str = "__config.yaml", outdir=None, override: bool = False
+    ) -> None:
+        """
+        Save the configuration to the output directory.
+        """
+        if outdir is not None:
+            output_dir = outdir
+        else:
+            output_dir = self.get_outdir()
+        os.makedirs(output_dir, exist_ok=True)
+        assert (output_dir is not None) and (
+            os.path.isdir(output_dir)
+        ), f"Output directory '{output_dir}' does not exist or is not a directory."
+        file_path = os.path.join(output_dir, filename)
+        if os.path.exists(file_path) and not override:
+            pprint(
+                f"File '{file_path}' already exists. Use 'override=True' to overwrite."
+            )
+        else:
+            # method of YAMLWizard to_yaml_file
+            self.to_yaml_file(file_path)
+
+    @classmethod
+    @abstractmethod
+    # load from a custom YAML file
+    def from_custom_yaml_file(cls, yaml_file: str):
+        """Load a configuration from a custom YAML file."""
+        pass
+
+    def get_cfg_name(self, sep: str = "__", *args, **kwargs) -> str:
+        # auto get the config name from dataset, method, metric
+        # 2. Generate the canonical Config Name
+        name_parts = []
+        general_info = self.get_general_cfg().get_name()
+        dataset_info = self.get_dataset_cfg().get_name()
+        method_info = self.get_method_cfg().get_name()
+        name_parts = [
+            general_info,
+            f"ds_{dataset_info}",
+            f"mt_{method_info}",
+        ]
+        if "extra" in kwargs:
+            extra_info = kwargs["extra"]
+            assert isinstance(extra_info, str), "'extra' kwarg must be a string."
+            name_parts.append(extra_info)
+        self.cfg_name = sep.join(name_parts)
+        return self.cfg_name
+
+    @abstractmethod
+    def get_outdir(self):
+        """
+        Get the output directory for the configuration.
+        This method should be implemented in subclasses.
+        """
+        return None
+
+    @abstractmethod
+    def get_general_cfg(self) -> NamedCfg:
+        """
+        Get the general configuration like output directory, log settings, SEED, etc.
+        This method should be implemented in subclasses.
+        """
+        pass
+
+    @abstractmethod
+    def get_dataset_cfg(self) -> NamedCfg:
+        """
+        Get the dataset configuration.
+        This method should be implemented in subclasses.
+        """
+        pass
+
+    @abstractmethod
+    def get_method_cfg(self) -> NamedCfg:
+        """
+        Get the method configuration.
+        This method should be implemented in subclasses.
+        """
+        pass
+
+    @abstractmethod
+    def get_metric_cfg(self) -> NamedCfg:
+        """
+        Get the metric configuration.
+        This method should be implemented in subclasses.
+        """
+        pass

halib/exp/core/base_exp.py

@@ -0,0 +1,147 @@
+from abc import ABC, abstractmethod
+from typing import Tuple, Any, Optional
+from .base_config import ExpBaseCfg
+from ..perf.perfcalc import PerfCalc
+from ..perf.perfmetrics import MetricsBackend
+
+
+class ExpHook:
+    """Base interface for all experiment hooks."""
+    def on_before_run(self, exp): pass
+    def on_after_run(self, exp, results): pass
+
+
+# ! SEE https://github.com/hahv/base_exp for sample usage
+class BaseExp(PerfCalc, ABC):
+    """
+    Base class for experiments.
+    Orchestrates the experiment pipeline using a pluggable metrics backend.
+    """
+
+    def __init__(self, config: ExpBaseCfg):
+        self.config = config
+        self.metric_backend = None
+        # Flag to track if init_general/prepare_dataset has run
+        self._is_env_ready = False
+        self.hooks = []
+
+    def register_hook(self, hook: ExpHook):
+        self.hooks.append(hook)
+
+    def _trigger_hooks(self, method_name: str, *args, **kwargs):
+        for hook in self.hooks:
+            method = getattr(hook, method_name, None)
+            if callable(method):
+                method(*args, **kwargs)
+
+    # -----------------------
+    # PerfCalc Required Methods
+    # -----------------------
+    def get_dataset_name(self):
+        return self.config.get_dataset_cfg().get_name()
+
+    def get_experiment_name(self):
+        return self.config.get_cfg_name()
+
+    def get_metric_backend(self):
+        if not self.metric_backend:
+            self.metric_backend = self.prepare_metrics(self.config.get_metric_cfg())
+        return self.metric_backend
+
+    # -----------------------
+    # Abstract Experiment Steps
+    # -----------------------
+    @abstractmethod
+    def init_general(self, general_cfg):
+        """Setup general settings like SEED, logging, env variables."""
+        pass
+
+    @abstractmethod
+    def prepare_dataset(self, dataset_cfg):
+        """Load/prepare dataset."""
+        pass
+
+    @abstractmethod
+    def prepare_metrics(self, metric_cfg) -> MetricsBackend:
+        """
+        Prepare the metrics for the experiment.
+        This method should be implemented in subclasses.
+        """
+        pass
+
+    @abstractmethod
+    def exec_exp(self, *args, **kwargs) -> Optional[Tuple[Any, Any]]:
+        """Run experiment process, e.g.: training/evaluation loop.
+        Return: either `None` or a tuple of (raw_metrics_data, extra_data) for calc_and_save_exp_perfs
+        """
+        pass
+
+    # -----------------------
+    # Internal Helpers
+    # -----------------------
+    def _validate_and_unpack(self, results):
+        if results is None:
+            return None
+        if not isinstance(results, (tuple, list)) or len(results) != 2:
+            raise ValueError("exec must return (metrics_data, extra_data)")
+        return results[0], results[1]
+
+    def _prepare_environment(self, force_reload: bool = False):
+        """
+        Common setup. Skips if already initialized, unless force_reload is True.
+        """
+        if self._is_env_ready and not force_reload:
+            # Environment is already prepared, skipping setup.
+            return
+
+        # 1. Run Setup
+        self.init_general(self.config.get_general_cfg())
+        self.prepare_dataset(self.config.get_dataset_cfg())
+
+        # 2. Update metric backend (refresh if needed)
+        self.metric_backend = self.prepare_metrics(self.config.get_metric_cfg())
+
+        # 3. Mark as ready
+        self._is_env_ready = True
+
+    # -----------------------
+    # Main Experiment Runner
+    # -----------------------
+    def run_exp(self, should_calc_metrics=True, reload_env=False, *args, **kwargs):
+        """
+        Run the whole experiment pipeline.
+        :param reload_env: If True, forces dataset/general init to run again.
+        :param should_calc_metrics: Whether to calculate and save metrics after execution.
+        :kwargs Params:
+            + 'outfile' to save csv file results,
+            + 'outdir' to set output directory for experiment results.
+            + 'return_df' to return a DataFrame of results instead of a dictionary.
+
+        Full pipeline:
+            1. Init
+            2. Prepare Environment (General + Dataset + Metrics)
+            3. Save Config
+            4. Execute
+            5. Calculate & Save Metrics
+        """
+        self._prepare_environment(force_reload=reload_env)
+
+        self._trigger_hooks("before_run", self)
+
+        # Save config before running
+        self.config.save_to_outdir()
+
+        # Execute experiment
+        results = self.exec_exp(*args, **kwargs)
+
+        if should_calc_metrics and results is not None:
+            metrics_data, extra_data = self._validate_and_unpack(results)
+            # Calculate & Save metrics
+            perf_results = self.calc_perfs(
+                raw_metrics_data=metrics_data, extra_data=extra_data, *args, **kwargs
+            )
+            self._trigger_hooks("after_run", self, perf_results)
+            return perf_results
+        else:
+            self._trigger_hooks("after_run", self, results)
+            return results

halib/exp/core/param_gen.py

@@ -0,0 +1,189 @@
+import os
+import copy
+import numpy as np
+from itertools import product
+from typing import Dict, Any, List, Iterator, Optional
+from ...filetype import yamlfile
+
+class ParamGen:
+    """
+    A flexible parameter grid generator for hyperparameter tuning and experiment management.
+
+    This class generates a Cartesian product of parameters from a "sweep configuration"
+    and optionally merges them into a "base configuration". It abstracts away the complexity
+    of handling nested dictionaries and range generation.
+
+    Key Features:
+    -----------
+    1. **Flexible Syntax**: Define parameters using standard nested dictionaries or
+       dot-notation keys (e.g., `'model.backbone.layers'`).
+    2. **Range Shortcuts**:
+       - **Choices**: Standard lists `[1, 2, 3]`.
+       - **String Ranges**: `"start:stop:step"` (e.g., `"0:10:2"` -> `[0, 2, 4, 6, 8]`).
+       - **Dict Ranges**: `{'start': 0, 'stop': 1, 'step': 0.1}`.
+    3. **Deep Merging**: Automatically updates deep keys in `base_cfg` without overwriting siblings.
+
+    Example:
+    --------
+    >>> base = {'model': {'name': 'resnet', 'dropout': 0.1}, 'seed': 42}
+    >>> sweep = {
+    ...     'model.name': ['resnet', 'vit'],      # Dot notation
+    ...     'model.dropout': "0.1:0.3:0.1",       # Range string
+    ...     'seed': [42, 100]                     # Simple choice
+    ... }
+    >>> grid = ParamGen(sweep, base)
+    >>> configs = grid.expand()
+    >>> print(len(configs))  # Outputs: 8 (2 models * 2 dropouts * 2 seeds)
+    Attributes:
+        keys (List[str]): List of flattened dot-notation keys being swept.
+        values (List[List[Any]]): List of value options for each key.
+    """
+    def __init__(
+        self, sweep_cfg: Dict[str, Any], base_cfg: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Args:
+            sweep_cfg: The dictionary defining parameters to sweep.
+            base_cfg: (Optional) The base config to merge sweep parameters into.
+                      If None, expand() behaves like expand_sweep().
+        """
+        self.base_cfg = base_cfg if base_cfg is not None else {}
+
+        # Recursively flatten the nested sweep config into dot-notation keys
+        self.param_space = self._flatten_params(sweep_cfg)
+        self.keys = list(self.param_space.keys())
+        self.values = list(self.param_space.values())
+
+    def get_param_space(self) -> Dict[str, List[Any]]:
+        """Returns the parameter space as a dictionary of dot-notation keys to value lists."""
+        return self.param_space
+
+    def __iter__(self) -> Iterator[Dict[str, Any]]:
+        """Yields fully merged configurations one by one."""
+        for combination in product(*self.values):
+            # 1. Create the flat sweep dict (dot notation)
+            flat_params = dict(zip(self.keys, combination))
+
+            # 2. Deep copy base and update with current params
+            new_cfg = copy.deepcopy(self.base_cfg)
+            new_cfg = self._apply_updates(new_cfg, flat_params)
+
+            # 3. Store metadata (Optional)
+            # if "_meta" not in new_cfg:
+            #     new_cfg["_meta"] = {}
+            # We unflatten the sweep params here so the log is readable
+            # new_cfg["_meta"]["sweep_params"] = self._unflatten(flat_params)
+
+            yield new_cfg
+
+    # ! --- Factory Methods ---
+    @classmethod
+    def from_dicts(
+        cls, sweep_cfg: Dict[str, Any], base_cfg: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Load from dictionaries.
+        Args:
+            sweep_cfg: The dictionary defining parameters to sweep.
+            base_cfg: (Optional) The base config to merge sweep parameters into.
+        """
+        return cls(sweep_cfg, base_cfg)
+
+    @classmethod
+    def from_files(cls, sweep_yaml: str, base_yaml: Optional[str] = None):
+        """
+        Load from files.
+        Args:
+            sweep_yaml: Path to sweep config.
+            base_yaml: (Optional) Path to base config.
+        """
+        assert os.path.isfile(sweep_yaml), f"Sweep file not found: {sweep_yaml}"
+        sweep_dict = yamlfile.load_yaml(sweep_yaml, to_dict=True)
+        base_dict = None
+        if base_yaml:
+            base_dict = yamlfile.load_yaml(base_yaml, to_dict=True)
+            if "__base__" in base_dict:
+                del base_dict["__base__"]
+
+        return cls(sweep_dict, base_dict)
+
+    def expand(self) -> List[Dict[str, Any]]:
+        """Generates and returns the full list of MERGED configurations."""
+        return list(self)
+
+    def expand_sweep_flat(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of ONLY the sweep parameters, formatted as FLAT dot-notation dictionaries.
+
+        Returns:
+            [{'exp_params.model': 'resnet', 'exp_params.lr': 0.01}, ...]
+        """
+        combinations = []
+        for combination in product(*self.values):
+            flat_dict = dict(zip(self.keys, combination))
+            combinations.append(flat_dict)
+        return combinations
+
+    def _unflatten(self, flat_dict: Dict[str, Any]) -> Dict[str, Any]:
+        """Converts {'a.b': 1} back to {'a': {'b': 1}}."""
+        nested = {}
+        self._apply_updates(nested, flat_dict)
+        return nested
+
+    def _flatten_params(
+        self, cfg: Dict[str, Any], parent_key: str = ""
+    ) -> Dict[str, List[Any]]:
+        """Recursively converts nested dicts into flat dot-notation keys."""
+        flat = {}
+        for key, val in cfg.items():
+            current_key = f"{parent_key}.{key}" if parent_key else key
+
+            if self._is_sweep_leaf(val):
+                flat[current_key] = self._expand_val(val)
+            elif isinstance(val, dict):
+                flat.update(self._flatten_params(val, current_key))
+            else:
+                flat[current_key] = [val]
+        return flat
+
+    def _is_sweep_leaf(self, val: Any) -> bool:
+        if isinstance(val, list):
+            return True
+        if isinstance(val, str) and ":" in val:
+            return True
+        if isinstance(val, dict) and "start" in val and "stop" in val:
+            return True
+        return False
+
+    def _expand_val(self, val: Any) -> List[Any]:
+        if isinstance(val, list):
+            return val
+
+        if isinstance(val, str) and ":" in val:
+            try:
+                parts = [float(x) for x in val.split(":")]
+                if len(parts) == 3:
+                    arr = np.arange(parts[0], parts[1], parts[2])
+                    return [float(f"{x:.6g}") for x in arr]
+            except ValueError:
+                pass
+
+        if isinstance(val, dict) and "start" in val:
+            step = val.get("step", 1)
+            return np.arange(val["start"], val["stop"], step).tolist()
+
+        return [val]
+
+    def _apply_updates(
+        self, cfg: Dict[str, Any], updates: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Deep merges dot-notation updates into cfg."""
+        for key, val in updates.items():
+            parts = key.split(".")
+            target = cfg
+            for part in parts[:-1]:
+                if part not in target:
+                    target[part] = {}
+                target = target[part]
+            target[parts[-1]] = val
+        return cfg

halib/exp/core/wandb_op.py

@@ -0,0 +1,117 @@
+import os
+import glob
+import wandb
+import argparse
+import subprocess
+
+from tqdm import tqdm
+from rich.console import Console
+
+console = Console()
+
+def sync_runs(outdir):
+    outdir = os.path.abspath(outdir)
+    assert os.path.exists(outdir), f"Output directory {outdir} does not exist."
+    sub_dirs = [name for name in os.listdir(outdir) if os.path.isdir(os.path.join(outdir, name))]
+    assert len(sub_dirs) > 0, f"No subdirectories found in {outdir}."
+    console.rule("Parent Directory")
+    console.print(f"[yellow]{outdir}[/yellow]")
+
+    exp_dirs = [os.path.join(outdir, sub_dir) for sub_dir in sub_dirs]
+    wandb_dirs = []
+    for exp_dir in exp_dirs:
+        wandb_dirs.extend(glob.glob(f"{exp_dir}/wandb/*run-*"))
+    if len(wandb_dirs) == 0:
+        console.print(f"No wandb runs found in {outdir}.")
+        return
+    else:
+        console.print(f"Found [bold]{len(wandb_dirs)}[/bold] wandb runs in {outdir}.")
+        for i, wandb_dir in enumerate(wandb_dirs):
+            console.rule(f"Syncing wandb run {i + 1}/{len(wandb_dirs)}")
+            console.print(f"Syncing: {wandb_dir}")
+            process = subprocess.Popen(
+                ["wandb", "sync", wandb_dir],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+            )
+
+            for line in process.stdout:
+                console.print(line.strip())
+                if " ERROR Error while calling W&B API" in line:
+                    break
+            process.stdout.close()
+            process.wait()
+            if process.returncode != 0:
+                console.print(f"[red]Error syncing {wandb_dir}. Return code: {process.returncode}[/red]")
+            else:
+                console.print(f"Successfully synced {wandb_dir}.")
+
+def delete_runs(project, pattern=None):
+    console.rule("Delete W&B Runs")
+    confirm_msg = f"Are you sure you want to delete all runs in"
+    confirm_msg += f" \n\tproject: [red]{project}[/red]"
+    if pattern:
+        confirm_msg += f"\n\tpattern: [blue]{pattern}[/blue]"
+
+    console.print(confirm_msg)
+    confirmation = input(f"This action cannot be undone. [y/N]: ").strip().lower()
+    if confirmation != "y":
+        print("Cancelled.")
+        return
+
+    print("Confirmed. Proceeding...")
+    api = wandb.Api()
+    runs = api.runs(project)
+
+    deleted = 0
+    console.rule("Deleting W&B Runs")
+    if len(runs) == 0:
+        print("No runs found in the project.")
+        return
+    for run in tqdm(runs):
+        if pattern is None or pattern in run.name:
+            run.delete()
+            console.print(f"Deleted run: [red]{run.name}[/red]")
+            deleted += 1
+
+    console.print(f"Total runs deleted: {deleted}")
+
+
+def valid_argument(args):
+    if args.op == "sync":
+        assert os.path.exists(args.outdir), f"Output directory {args.outdir} does not exist."
+    elif args.op == "delete":
+        assert isinstance(args.project, str) and len(args.project.strip()) > 0, "Project name must be a non-empty string."
+    else:
+        raise ValueError(f"Unknown operation: {args.op}")
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Operations on W&B runs")
+    parser.add_argument("-op", "--op", type=str, help="Operation to perform", default="sync", choices=["delete", "sync"])
+    parser.add_argument("-prj", "--project", type=str, default="fire-paper2-2025", help="W&B project name")
+    parser.add_argument("-outdir", "--outdir", type=str, help="arg1 description", default="./zout/train")
+    parser.add_argument("-pt", "--pattern",
+        type=str,
+        default=None,
+        help="Run name pattern to match for deletion",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    # Validate arguments, stop if invalid
+    valid_argument(args)
+
+    op = args.op
+    if op == "sync":
+        sync_runs(args.outdir)
+    elif op == "delete":
+        delete_runs(args.project, args.pattern)
+    else:
+        raise ValueError(f"Unknown operation: {op}")
+
+if __name__ == "__main__":
+    main()

halib/exp/data/dataclass_util.py

@@ -0,0 +1,41 @@
+import yaml
+from typing import Any
+
+from rich.pretty import pprint
+from dataclasses import make_dataclass
+
+from ...filetype import yamlfile
+
+def dict_to_dataclass(name: str, data: dict):
+    fields = []
+    values = {}
+
+    for key, value in data.items():
+        if isinstance(value, dict):
+            sub_dc = dict_to_dataclass(key.capitalize(), value)
+            fields.append((key, type(sub_dc)))
+            values[key] = sub_dc
+        else:
+            field_type = type(value) if value is not None else Any
+            fields.append((key, field_type))
+            values[key] = value
+
+    DC = make_dataclass(name.capitalize(), fields)
+    return DC(**values)
+
+def yaml_to_dataclass(name: str, yaml_str: str):
+    data = yaml.safe_load(yaml_str)
+    return dict_to_dataclass(name, data)
+
+
+def yamlfile_to_dataclass(name: str, file_path: str):
+    data_dict = yamlfile.load_yaml(file_path, to_dict=True)
+    if "__base__" in data_dict:
+        del data_dict["__base__"]
+    return dict_to_dataclass(name, data_dict)
+
+if __name__ == "__main__":
+    cfg = yamlfile_to_dataclass("Config", "test/dataclass_util_test_cfg.yaml")
+
+    # ! NOTICE: after print out this dataclass, we can copy the output and paste it into CHATGPT to generate a list of needed dataclass classes using `from dataclass_wizard import YAMLWizard`
+    pprint(cfg)