|
|
| """Reusable PyTorch datasets backed by CSV image indexes."""
|
|
|
| from __future__ import annotations
|
|
|
| import csv
|
| import json
|
| import sys
|
| from dataclasses import dataclass
|
| from pathlib import Path
|
| from typing import Any, Callable, Literal
|
|
|
| from PIL import Image
|
| from torch.utils.data import Dataset
|
|
|
|
|
| csv.field_size_limit(min(sys.maxsize, 2_147_483_647))
|
|
|
| LabelMode = Literal["binary", "ai_model", "real_source", "unified"]
|
|
|
|
|
| @dataclass(frozen=True)
|
| class IndexedSample:
|
| image_path: str
|
| label: int
|
| label_type: str
|
| source_name: str
|
| row: dict[str, str]
|
|
|
|
|
| class CSVIndexDataset(Dataset):
|
| """Dataset for AI/real CSV image indexes.
|
|
|
| Label modes:
|
| - binary: AI=1, real=0.
|
| - ai_model: AI samples use source_model_id; real samples use 0.
|
| - real_source: real samples use real_source_id; AI samples use 1.
|
| - unified: AI samples use source_model_id; real samples use negative real_source_id.
|
| """
|
|
|
| def __init__(
|
| self,
|
| csv_paths: str | Path | list[str | Path],
|
| transform: Callable[[Image.Image], Any] | None = None,
|
| label_mode: LabelMode = "binary",
|
| return_metadata: bool = False,
|
| ):
|
| self.csv_paths = [Path(csv_paths)] if isinstance(csv_paths, (str, Path)) else [Path(p) for p in csv_paths]
|
| self.transform = transform
|
| self.label_mode = label_mode
|
| self.return_metadata = return_metadata
|
| self.samples = self._load_samples()
|
|
|
| def _load_samples(self) -> list[IndexedSample]:
|
| samples: list[IndexedSample] = []
|
| for csv_path in self.csv_paths:
|
| with csv_path.open("r", newline="", encoding="utf-8") as f:
|
| reader = csv.DictReader(f)
|
| for row in reader:
|
| image_path = row.get("image_path", "")
|
| if not image_path:
|
| continue
|
| label_type = row.get("label_type", "")
|
| source_name = row.get("source_model_name") or row.get("real_source_label") or row.get("source_dataset", "")
|
| samples.append(
|
| IndexedSample(
|
| image_path=image_path,
|
| label=self._label_for_row(row),
|
| label_type=label_type,
|
| source_name=source_name,
|
| row=row,
|
| )
|
| )
|
| return samples
|
|
|
| def _label_for_row(self, row: dict[str, str]) -> int:
|
| label_type = row.get("label_type")
|
| if self.label_mode == "binary":
|
| return int(float(row.get("binary_label", 0)))
|
| if self.label_mode == "ai_model":
|
| return int(row.get("source_model_id") or 0)
|
| if self.label_mode == "real_source":
|
| if label_type == "real":
|
| return int(row.get("real_source_id") or 0)
|
| return 1
|
| if self.label_mode == "unified":
|
| if label_type == "real":
|
| return int(row.get("real_source_id") or 0)
|
| return int(row.get("source_model_id") or 0)
|
| raise ValueError(f"Unsupported label_mode: {self.label_mode}")
|
|
|
| def __len__(self) -> int:
|
| return len(self.samples)
|
|
|
| def __getitem__(self, idx: int):
|
| sample = self.samples[idx]
|
| image = Image.open(sample.image_path).convert("RGB")
|
| if self.transform is not None:
|
| image = self.transform(image)
|
| if self.return_metadata:
|
| return image, sample.label, sample.row
|
| return image, sample.label
|
|
|
|
|
| def load_dataset_summary(path: str | Path) -> dict[str, Any]:
|
| with Path(path).open("r", encoding="utf-8") as f:
|
| return json.load(f)
|
|
|
|
|
| def main() -> None:
|
| import argparse
|
|
|
| parser = argparse.ArgumentParser(description="Inspect CSV index dataset sizes.")
|
| parser.add_argument("csv", nargs="+", type=Path)
|
| parser.add_argument("--label-mode", choices=["binary", "ai_model", "real_source", "unified"], default="binary")
|
| args = parser.parse_args()
|
| ds = CSVIndexDataset(args.csv, label_mode=args.label_mode)
|
| counts: dict[int, int] = {}
|
| type_counts: dict[str, int] = {}
|
| for sample in ds.samples:
|
| counts[sample.label] = counts.get(sample.label, 0) + 1
|
| type_counts[sample.label_type] = type_counts.get(sample.label_type, 0) + 1
|
| print(json.dumps({"total": len(ds), "label_counts": counts, "type_counts": type_counts}, indent=2))
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
