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

halib/research/core/param_gen.py

@@ -0,0 +1,108 @@
+import os
+import yaml
+import numpy as np
+from typing import Dict, Any, List
+
+from ...common.common import *
+from ...filetype import yamlfile
+
+class ParamGen:
+    @staticmethod
+    def build_from_file(params_file):
+        builder = ParamGen(params_file)
+        return builder.params
+
+    def __init__(self, params_file=None):
+        self.params = {}
+        assert os.path.isfile(params_file), f"params_file not found: {params_file}"
+        self.params = self._build(params_file)
+
+    def _expand_param(self, param_name: str, config: Dict[str, Any]) -> List[Any]:
+        """
+        Validates and expands the values for a single parameter configuration.
+
+        Args:
+            param_name: The name of the parameter being processed.
+            config: The configuration dictionary for this parameter.
+
+        Returns:
+            A list of the expanded values for the parameter.
+
+        Raises:
+            TypeError: If the configuration or its values have an incorrect type.
+            ValueError: If the configuration is missing keys or has an invalid structure.
+        """
+        # 1. Validate the configuration structure
+        if not isinstance(config, dict):
+            raise TypeError(f"Config for '{param_name}' must be a dictionary.")
+
+        if "type" not in config or "values" not in config:
+            raise ValueError(
+                f"Config for '{param_name}' must contain 'type' and 'values' keys."
+            )
+
+        gen_type = config["type"]
+        values = config["values"]
+
+        # 2. Handle the generation based on type
+        if gen_type == "list":
+            # Ensure values are returned as a list, even if a single item was provided
+            return values if isinstance(values, list) else [values]
+
+        elif gen_type == "range":
+            if not isinstance(values, list) or len(values) != 3:
+                raise ValueError(
+                    f"For 'range' type on '{param_name}', 'values' must be a list of 3 numbers "
+                    f"[start, end, step], but got: {values}"
+                )
+
+            start, end, step = values
+            if all(isinstance(v, int) for v in values):
+                return list(range(start, end, step))
+            elif all(isinstance(v, (int, float)) for v in values):
+                # Use numpy for floating point ranges
+                temp_list = list(np.arange(start, end, step))
+                # convert to float (not np.float)
+                return [float(v) for v in temp_list]
+            else:
+                raise TypeError(
+                    f"All 'values' for 'range' on '{param_name}' must be numbers."
+                )
+
+        else:
+            raise ValueError(
+                f"Invalid 'type' for '{param_name}': '{gen_type}'. Must be 'list' or 'range'."
+            )
+
+    def _build(self, params_file):
+        """
+        Builds a full optimization configuration by expanding parameter values based on their type.
+
+        This function processes a dictionary where each key is a parameter name and each value
+        is a config dict specifying the 'type' ('list' or 'range') and 'values' for generation.
+
+        Args:
+            opt_cfg: The input configuration dictionary.
+                    Example:
+                    {
+                        "learning_rate": {"type": "range", "values": [0.01, 0.1, 0.01]},
+                        "optimizer": {"type": "list", "values": ["adam", "sgd"]},
+                        "epochs": {"type": "list", "values": 100}
+                    }
+
+        Returns:
+            A dictionary with parameter names mapped to their fully expanded list of values.
+        """
+        cfg_raw_dict = yamlfile.load_yaml(params_file, to_dict=True)
+        if not isinstance(cfg_raw_dict, dict):
+            raise TypeError("The entire opt_cfg must be a dictionary.")
+
+        # Use a dictionary comprehension for a clean and efficient build
+        return {
+            param_name: self._expand_param(param_name, config)
+            for param_name, config in cfg_raw_dict.items()
+        }
+
+    def save(self, outfile):
+        with open(outfile, "w") as f:
+            yaml.dump(self.params, f)

halib/research/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/research/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)

halib/research/data/dataset.py

@@ -0,0 +1,208 @@
+# This script create a test version
+# of the watcam (wc) dataset
+# for testing the tflite model
+
+from argparse import ArgumentParser
+
+import os
+import click
+import shutil
+from tqdm import tqdm
+from rich import inspect
+from rich.pretty import pprint
+from torchvision.datasets import ImageFolder
+from sklearn.model_selection import StratifiedShuffleSplit, ShuffleSplit
+
+from ...common.common import console, seed_everything, ConsoleLog
+from ...system import filesys as fs
+
+def parse_args():
+    parser = ArgumentParser(description="desc text")
+    parser.add_argument(
+        "-indir",
+        "--indir",
+        type=str,
+        help="orignal dataset path",
+    )
+    parser.add_argument(
+        "-outdir",
+        "--outdir",
+        type=str,
+        help="dataset out path",
+        default=".",  # default to current dir
+    )
+    parser.add_argument(
+        "-val_size",
+        "--val_size",
+        type=float,
+        help="validation size",  # no default value to force user to input
+        default=0.2,
+    )
+    # add using StratifiedShuffleSplit or ShuffleSplit
+    parser.add_argument(
+        "-seed",
+        "--seed",
+        type=int,
+        help="random seed",
+        default=42,
+    )
+    parser.add_argument(
+        "-inplace",
+        "--inplace",
+        action="store_true",
+        help="inplace operation, will overwrite the outdir if exists",
+    )
+
+    parser.add_argument(
+        "-stratified",
+        "--stratified",
+        action="store_true",
+        help="use StratifiedShuffleSplit instead of ShuffleSplit",
+    )
+    parser.add_argument(
+        "-no_train",
+        "--no_train",
+        action="store_true",
+        help="only create test set, no train set",
+    )
+    parser.add_argument(
+        "-reverse",
+        "--reverse",
+        action="store_true",
+        help="combine train and val set back to original dataset",
+    )
+    return parser.parse_args()
+
+
+def move_images(image_paths, target_set_dir):
+    for img_path in tqdm(image_paths):
+        # get folder name of the image
+        img_dir = os.path.dirname(img_path)
+        out_cls_dir = os.path.join(target_set_dir, os.path.basename(img_dir))
+        if not os.path.exists(out_cls_dir):
+            os.makedirs(out_cls_dir)
+        # move the image to the class folder
+        shutil.move(img_path, out_cls_dir)
+
+
+def split_dataset_cls(
+    indir, outdir, val_size, seed, inplace, stratified_split, no_train
+):
+    seed_everything(seed)
+    console.rule("Config confirm?")
+    pprint(locals())
+    click.confirm("Continue?", abort=True)
+    assert os.path.exists(indir), f"{indir} does not exist"
+
+    if not inplace:
+        assert (not inplace) and (
+            not os.path.exists(outdir)
+        ), f"{outdir} already exists; SKIP ...."
+
+    if inplace:
+        outdir = indir
+    if not os.path.exists(outdir):
+        os.makedirs(outdir)
+
+    console.rule(f"Creating train/val dataset")
+
+    sss = (
+        ShuffleSplit(n_splits=1, test_size=val_size)
+        if not stratified_split
+        else StratifiedShuffleSplit(n_splits=1, test_size=val_size)
+    )
+
+    pprint({"split strategy": sss, "indir": indir, "outdir": outdir})
+    dataset = ImageFolder(
+        root=indir,
+        transform=None,
+    )
+    train_dataset_indices = None
+    val_dataset_indices = None  # val here means test
+    for train_indices, val_indices in sss.split(dataset.samples, dataset.targets):
+        train_dataset_indices = train_indices
+        val_dataset_indices = val_indices
+
+    # get image paths for train/val split dataset
+    train_image_paths = [dataset.imgs[i][0] for i in train_dataset_indices]
+    val_image_paths = [dataset.imgs[i][0] for i in val_dataset_indices]
+
+    # start creating train/val folders then move images
+    out_train_dir = os.path.join(outdir, "train")
+    out_val_dir = os.path.join(outdir, "val")
+    if inplace:
+        assert os.path.exists(out_train_dir) == False, f"{out_train_dir} already exists"
+        assert os.path.exists(out_val_dir) == False, f"{out_val_dir} already exists"
+
+    os.makedirs(out_train_dir)
+    os.makedirs(out_val_dir)
+
+    if not no_train:
+        with ConsoleLog(f"Moving train images to {out_train_dir} "):
+            move_images(train_image_paths, out_train_dir)
+    else:
+        pprint("test only, skip moving train images")
+        # remove out_train_dir
+        shutil.rmtree(out_train_dir)
+
+    with ConsoleLog(f"Moving val images to {out_val_dir} "):
+        move_images(val_image_paths, out_val_dir)
+
+    if inplace:
+        pprint(f"remove all folders, except train and val")
+        for cls_dir in os.listdir(outdir):
+            if cls_dir not in ["train", "val"]:
+                shutil.rmtree(os.path.join(indir, cls_dir))
+
+
+def reverse_split_ds(indir):
+    console.rule(f"Reversing split dataset <{indir}>...")
+    ls_dirs = os.listdir(indir)
+    # make sure there are only two dirs 'train' and 'val'
+    assert len(ls_dirs) == 2, f"Found more than 2 dirs: {len(ls_dirs) } dirs"
+    assert "train" in ls_dirs, f"train dir not found in {indir}"
+    assert "val" in ls_dirs, f"val dir not found in {indir}"
+    train_dir = os.path.join(indir, "train")
+    val_dir = os.path.join(indir, "val")
+    all_train_files = fs.filter_files_by_extension(
+        train_dir, ["jpg", "jpeg", "png", "bmp", "gif", "tiff"]
+    )
+    all_val_files = fs.filter_files_by_extension(
+        val_dir, ["jpg", "jpeg", "png", "bmp", "gif", "tiff"]
+    )
+    # move all files from train to indir
+    with ConsoleLog(f"Moving train images to {indir} "):
+        move_images(all_train_files, indir)
+    with ConsoleLog(f"Moving val images to {indir} "):
+        move_images(all_val_files, indir)
+    with ConsoleLog(f"Removing train and val dirs"):
+        # remove train and val dirs
+        shutil.rmtree(train_dir)
+        shutil.rmtree(val_dir)
+
+
+def main():
+    args = parse_args()
+    indir = args.indir
+    outdir = args.outdir
+    if outdir == ".":
+        # get current folder of the indir
+        indir_parent_dir = os.path.dirname(os.path.normpath(indir))
+        indir_name = os.path.basename(indir)
+        outdir = os.path.join(indir_parent_dir, f"{indir_name}_split")
+    val_size = args.val_size
+    seed = args.seed
+    inplace = args.inplace
+    stratified_split = args.stratified
+    no_train = args.no_train
+    reverse = args.reverse
+    if not reverse:
+        split_dataset_cls(
+            indir, outdir, val_size, seed, inplace, stratified_split, no_train
+        )
+    else:
+        reverse_split_ds(indir)
+
+
+if __name__ == "__main__":
+    main()

halib/research/data/torchloader.py

@@ -0,0 +1,165 @@
+"""
+ * @author Hoang Van-Ha
+ * @email hoangvanhauit@gmail.com
+ * @create date 2024-03-27 15:40:22
+ * @modify date 2024-03-27 15:40:22
+ * @desc this module works as a utility tools for finding the best configuration for dataloader (num_workers, batch_size, pin_menory, etc.) that fits your hardware.
+"""
+from argparse import ArgumentParser
+
+import os
+import time
+import traceback
+
+from tqdm import tqdm
+from rich import inspect
+from typing import Union
+import itertools as it  # for cartesian product
+
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+
+from ...common.common import *
+from ...filetype import csvfile
+from ...filetype.yamlfile import load_yaml
+
+def parse_args():
+    parser = ArgumentParser(description="desc text")
+    parser.add_argument("-cfg", "--cfg", type=str, help="cfg file for searching")
+    return parser.parse_args()
+
+
+def get_test_range(cfg: dict, search_item="num_workers"):
+    item_search_cfg = cfg["search_space"].get(search_item, None)
+    if item_search_cfg is None:
+        raise ValueError(f"search_item: {search_item} not found in cfg")
+    if isinstance(item_search_cfg, list):
+        return item_search_cfg
+    elif isinstance(item_search_cfg, dict):
+        if "mode" in item_search_cfg:
+            mode = item_search_cfg["mode"]
+            assert mode in ["range", "list"], f"mode: {mode} not supported"
+            value_in_mode = item_search_cfg.get(mode, None)
+            if value_in_mode is None:
+                raise ValueError(f"mode<{mode}>: data not found in <{search_item}>")
+            if mode == "range":
+                assert len(value_in_mode) == 3, f"range must have 3 values: start, stop, step"
+                start = value_in_mode[0]
+                stop = value_in_mode[1]
+                step = value_in_mode[2]
+                return list(range(start, stop, step))
+            elif mode == "list":
+                return item_search_cfg["list"]
+    else:
+        return [item_search_cfg]  # for int, float, str, bool, etc.
+
+
+def load_an_batch(loader_iter):
+    start = time.time()
+    next(loader_iter)
+    end = time.time()
+    return end - start
+
+
+def test_dataloader_with_cfg(origin_dataloader: DataLoader, cfg: Union[dict, str]):
+    try:
+        if isinstance(cfg, str):
+            cfg = load_yaml(cfg, to_dict=True)
+        dfmk = csvfile.DFCreator()
+        search_items = ["batch_size", "num_workers", "persistent_workers", "pin_memory"]
+        batch_limit = cfg["general"]["batch_limit"]
+        csv_cfg = cfg["general"]["to_csv"]
+        log_batch_info = cfg["general"]["log_batch_info"]
+
+        save_to_csv = csv_cfg["enabled"]
+        log_dir = csv_cfg["log_dir"]
+        filename = csv_cfg["filename"]
+        filename = f"{now_str()}_{filename}.csv"
+        outfile = os.path.join(log_dir, filename)
+
+        dfmk.create_table(
+            "cfg_search",
+            (search_items + ["avg_time_taken"]),
+        )
+        ls_range_test = []
+        for item in search_items:
+            range_test = get_test_range(cfg, search_item=item)
+            range_test = [(item, i) for i in range_test]
+            ls_range_test.append(range_test)
+
+        all_combinations = list(it.product(*ls_range_test))
+
+        rows = []
+        for cfg_idx, combine in enumerate(all_combinations):
+            console.rule(f"Testing cfg {cfg_idx+1}/{len(all_combinations)}")
+            inspect(combine)
+            batch_size = combine[search_items.index("batch_size")][1]
+            num_workers = combine[search_items.index("num_workers")][1]
+            persistent_workers = combine[search_items.index("persistent_workers")][1]
+            pin_memory = combine[search_items.index("pin_memory")][1]
+
+            test_dataloader = DataLoader(origin_dataloader.dataset, batch_size=batch_size, num_workers=num_workers, persistent_workers=persistent_workers, pin_memory=pin_memory, shuffle=True)
+            row = [
+                batch_size,
+                num_workers,
+                persistent_workers,
+                pin_memory,
+                0.0,
+            ]
+
+            # calculate the avg time taken to load the data for <batch_limit> batches
+            trainiter = iter(test_dataloader)
+            time_elapsed = 0
+            pprint('Start testing...')
+            for i in tqdm(range(batch_limit)):
+                single_batch_time = load_an_batch(trainiter)
+                if log_batch_info:
+                    pprint(f"Batch {i+1} took {single_batch_time:.4f} seconds to load")
+                time_elapsed += single_batch_time
+            row[-1] = time_elapsed / batch_limit
+            rows.append(row)
+        dfmk.insert_rows('cfg_search', rows)
+        dfmk.fill_table_from_row_pool('cfg_search')
+        with ConsoleLog("results"):
+            csvfile.fn_display_df(dfmk['cfg_search'])
+            if save_to_csv:
+                dfmk["cfg_search"].to_csv(outfile, index=False)
+                console.print(f"[red] Data saved to <{outfile}> [/red]")
+
+    except Exception as e:
+        traceback.print_exc()
+        print(e)
+        # get current directory of this python file
+        current_dir = os.path.dirname(os.path.realpath(__file__))
+        standar_cfg_path = os.path.join(current_dir, "torchloader_search.yaml")
+        pprint(
+            f"Make sure you get the  right <cfg.yaml> file. An example of <cfg.yaml> file can be found at this path: {standar_cfg_path}"
+        )
+        return
+
+def main():
+    args = parse_args()
+    cfg_yaml = args.cfg
+    cfg_dict = load_yaml(cfg_yaml, to_dict=True)
+
+    # Define transforms for data augmentation and normalization
+    transform = transforms.Compose(
+        [
+            transforms.RandomHorizontalFlip(),  # Randomly flip images horizontally
+            transforms.RandomRotation(10),  # Randomly rotate images by 10 degrees
+            transforms.ToTensor(),  # Convert images to PyTorch tensors
+            transforms.Normalize(
+                (0.5, 0.5, 0.5), (0.5, 0.5, 0.5)
+            ),  # Normalize pixel values to [-1, 1]
+        ]
+    )
+    test_dataset = datasets.CIFAR10(
+        root="./data", train=False, download=True, transform=transform
+    )
+    batch_size = 64
+    train_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)
+    test_dataloader_with_cfg(train_loader, cfg_dict)
+
+
+if __name__ == "__main__":
+    main()

halib/research/dataset.py

@@ -13,8 +13,8 @@ from rich.pretty import pprint
 from torchvision.datasets import ImageFolder
 from sklearn.model_selection import StratifiedShuffleSplit, ShuffleSplit
 
-from ..system import filesys as fs
 from ..common import console, seed_everything, ConsoleLog
+from ..system import filesys as fs
 
 def parse_args():
     parser = ArgumentParser(description="desc text")

halib/research/metrics.py

@@ -11,6 +11,10 @@ class MetricsBackend(ABC):
     def __init__(self, metrics_info: Union[List[str], Dict[str, Any]]):
         """
         Initialize the backend with optional metrics_info.
+        `metrics_info` can be either:
+        - A list of metric names (strings). e.g., ["accuracy", "precision"]
+        - A dict mapping metric names with object that defines how to compute them. e.g: {"accuracy": torchmetrics.Accuracy(), "precision": torchmetrics.Precision()}
+
         """
         self.metric_info = metrics_info
         self.validate_metrics_info(self.metric_info)