scripts/dataset_creator.py

import argparse
import shutil
from dataclasses import dataclass, asdict
from math import ceil, floor
from pathlib import Path
from typing import Optional, TypeVar, Callable

import pandas  # ty:ignore[unresolved-import]

from common import ROOT_PATH, DATASET_PATH, parse_info_from_filename, create_rng_with_seed, read_json, \
    DATASET_FILENAME_DICT_PATH


@dataclass
class Sample:
    id: str
    split: Optional[str]
    index: int
    category: str
    model: str
    file: str
    file_name: Optional[str]
    origin_file: str
    mos: float
    light: float
    color: float
    noise: float
    exposure: float
    nature: float
    content_recovery: float
    description: str

    def _gen_metadata(self):
        self.file_name = Path(self.file).name

    def _hind_infos(self):
        self.mos = -1.0
        self.light = -1.0
        self.color = -1.0
        self.noise = -1.0
        self.exposure = -1.0
        self.nature = -1.0
        self.content_recovery = -1.0
        self.description = "The image..."

    def as_test(self, for_contest: bool):
        if for_contest:
            self._hind_infos()
        self.split = "test"
        self._gen_metadata()

    def as_train(self, for_test: bool):
        if for_test:
            self._hind_infos()
        self.split = "training"
        self._gen_metadata()

@dataclass
class Group:
    id: str
    split: Optional[str]
    index: int
    category: str
    avg_mos: float
    items: list[Sample]

    def set_split(self, split: str, for_contest: bool, for_test: bool):
        self.split = split
        for item in self.items:
            if split == "training":
                item.as_train(for_test=for_test)
            elif split == "test":
                item.as_test(for_contest=for_contest)


def find_by_stem(dir_path: Path, stem: str):
    for p in dir_path.iterdir():
        if p.is_file() and p.stem == stem:
            return p
    return None

def read_dataset_from_txt(for_contest: bool) -> list[Sample]:
    temp: dict = {}
    with open(DATASET_PATH / "data2.txt", encoding="utf-8", mode="r") as f:
        head_skipped = False
        for line in f:
            if not head_skipped:
                head_skipped = True
                continue
            filename, mos, description = line.strip().split(maxsplit=2)
            temp[filename] = {
                "mos": float(mos),
                "description": description
            }
    datasets: list[Sample] = []
    with open(DATASET_PATH / "shuxing.txt", encoding="utf-8", mode="r") as f:
        head_skipped = False
        for line in f:
            if not head_skipped:
                head_skipped = True
                continue
            filename, light, color, noise, exposure, nature, content_recovery = line.strip().split(maxsplit=7)
            id, category, index, model, suffix = parse_info_from_filename(filename)

            if for_contest:
                if not DATASET_FILENAME_DICT_PATH.exists():
                    raise Exception("you should rename dataset first")
                filename_dict = read_json(DATASET_FILENAME_DICT_PATH)
                id, _, _, _, _ = parse_info_from_filename(filename_dict[filename])

            exist_item = temp[filename]
            if exist_item is None:
                print(f"id {filename} not exist")
                continue
            file = DATASET_PATH / "data" / f"{id}.{suffix}"
            datasets.append(Sample(
                id=id,
                split=None,
                index=index,
                category=category,
                model=model,
                file=str(file.relative_to(ROOT_PATH)),
                file_name=None,
                origin_file=str(find_by_stem(DATASET_PATH / "low-light", f"{category[:1]}_{index}").relative_to(ROOT_PATH)),
                light=float(light),
                color=float(color),
                noise=float(noise),
                exposure=float(exposure),
                nature=float(nature),
                content_recovery=float(content_recovery),
                mos=float(exist_item["mos"]),
                description=exist_item["description"],
            ))
    return datasets

def group_dataset_by_origin(datasets: list[Sample]) -> list[Group]:
    group_datasets: dict[str, Group] = {}
    for dataset in datasets:
        group_id = f"{dataset.category}_{dataset.index}"
        group_dataset = group_datasets.get(group_id, None)
        if group_dataset is None:
            group_dataset = Group(
                id=group_id,
                split=None,
                index=dataset.index,
                category=dataset.category,
                avg_mos=0,
                items=[],
            )
        group_dataset.avg_mos += dataset.mos
        group_dataset.items.append(dataset)
        group_datasets[group_id] = group_dataset
    results = list(group_datasets.values())
    for result in results:
        result.avg_mos /= len(result.items)
    return results


ItemT = TypeVar('ItemT')
def bucket_by_unit_interval(data: list[ItemT], field_getter: Callable[[ItemT], float]) -> dict[tuple[int, int], list[Group]]:
    if not data:
        return {}

    data = sorted(data, key=field_getter)

    min_v = field_getter(data[0])
    max_v = field_getter(data[-1])

    start = floor(min_v)
    end = ceil(max_v)

    buckets = {(i, i + 1): [] for i in range(start, end)}

    for item in data:
        v = field_getter(item)
        idx = floor(v)
        if idx >= end:
            idx = end - 1
        buckets[(idx, idx + 1)].append(item)

    return buckets

FieldT = TypeVar('FieldT')
def split_by_field(data: list[ItemT], field_getter: Callable[[ItemT], FieldT]) -> dict[FieldT, list[ItemT]]:
    groups: dict[FieldT, list[ItemT]] = {}
    for item in data:
        attr = field_getter(item)
        if attr not in groups:
            groups[attr] = []
        groups[attr].append(item)
    return groups

def split_8_2(total: int, carry_err: float) -> tuple[int, int, float]:
    ideal_test = total * 0.2 + carry_err
    test_count = round(ideal_test)
    test_count = max(0, min(test_count, total))
    new_err = ideal_test - test_count
    train_count = total - test_count
    return train_count, test_count, new_err

def main(for_contest: bool, for_test: bool):
    rand = create_rng_with_seed()

    datasets = read_dataset_from_txt(for_contest=for_contest)
    group = group_dataset_by_origin(datasets=datasets)

    buckets = bucket_by_unit_interval(group, lambda group_item: group_item.avg_mos)
    all_groups: list[Group] = []
    for _, bucket in buckets.items():
        category_buckets = split_by_field(bucket, lambda bucket_item: bucket_item.category)
        bucket_train: list[Group] = []
        bucket_test: list[Group] = []
        split_error = 0.0
        for category, category_bucket in category_buckets.items():
            all_groups += category_bucket
            bucket_size = len(category_bucket)
            train_count, _, split_error = split_8_2(bucket_size, split_error)
            rand.shuffle(category_bucket)
            bucket_train += category_bucket[:train_count]
            bucket_test += category_bucket[train_count:]
        for group in bucket_train:
            group.set_split("training", for_contest=for_contest, for_test=for_test)
        for group in bucket_test:
            group.set_split("test", for_contest=for_contest, for_test=for_test)
    all_groups.sort(key=lambda x: (x.category, x.avg_mos))
    split_distribution = pandas.DataFrame([asdict(group) for group in all_groups])
    split_distribution = split_distribution.drop(columns=["items"])
    split_distribution.to_csv(ROOT_PATH / f"split_distribution.csv", index=False)

    datasets = split_by_field(datasets, lambda dataset_item: dataset_item.split)

    for split, dataset in datasets.items():
        if for_contest:
            for dataset_item in dataset:
                origin_path = (ROOT_PATH / dataset_item.file).resolve()
                target_base_path = origin_path.parent.parent / split
                target_base_path.mkdir(exist_ok=True, parents=True)
                target_path = target_base_path / origin_path.name
                dataset_item.file = str(target_path.relative_to(ROOT_PATH))
                shutil.copy2(origin_path, target_path)
        dataset.sort(key=lambda x: (x.split, x.category, x.index, x.id))
        data_frame = pandas.DataFrame([asdict(item) for item in dataset])
        drop_columns = ["split", "index", "category"]
        if for_contest:
            drop_columns += ["model", "origin_file"]
            if split == "test":
                drop_columns += ["mos", "light", "color", "noise", "exposure", "nature", "content_recovery", "description"]
        data_frame = data_frame.drop(columns=drop_columns)
        output_name = "" if for_contest else "-release"
        data_frame.drop(columns=["file_name"]).to_json(ROOT_PATH / f"MLE-{split}{output_name}.json", orient="records", index=False, indent=2)
        data_frame.drop(columns=["file"]).to_csv(DATASET_PATH / split / "metadata.csv", index=False)

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--for-contest",
        action="store_true",
        help="enable contest mode"
    )
    parser.add_argument(
        "--for-test",
        action="store_true",
        help="enable test mode"
    )
    args = parser.parse_args()

    main(for_contest=args.for_contest, for_test=args.for_test)