|
|
| 'Fit and evaluate an eight-class real-image-source classifier on frozen CLIP features.'
|
|
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import csv
|
| import json
|
| import random
|
| import sys
|
| from collections import defaultdict
|
| from pathlib import Path
|
|
|
| import numpy as np
|
| import torch
|
| import torch.nn.functional as F
|
| import torchvision.transforms as T
|
| from PIL import Image
|
| from sklearn.linear_model import LogisticRegression
|
| from sklearn.metrics import accuracy_score, balanced_accuracy_score, classification_report
|
| from torch.utils.data import DataLoader, Dataset
|
| from tqdm import tqdm
|
|
|
| try:
|
| import clip
|
| except ImportError:
|
| raise ImportError("Please install clip: pip install git+https://github.com/openai/CLIP.git")
|
|
|
|
|
| PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
| ARTIFACT_ROOT = PROJECT_ROOT / "artifacts"
|
| DEFAULT_SPLIT_DIR = ARTIFACT_ROOT / "metadata" / "fixed_split"
|
| CLIP_MEAN = [0.48145466, 0.4578275, 0.40821073]
|
| CLIP_STD = [0.26862954, 0.26130258, 0.27577711]
|
|
|
| csv.field_size_limit(min(sys.maxsize, 2_147_483_647))
|
|
|
|
|
| class RealSourceDataset(Dataset):
|
| def __init__(self, rows: list[dict[str, str]], label_to_idx: dict[str, int], transform):
|
| self.rows = rows
|
| self.label_to_idx = label_to_idx
|
| self.transform = transform
|
|
|
| def __len__(self) -> int:
|
| return len(self.rows)
|
|
|
| def __getitem__(self, idx: int):
|
| row = self.rows[idx]
|
| image = Image.open(row["image_path"]).convert("RGB")
|
| return self.transform(image), self.label_to_idx[row["source_dataset"]]
|
|
|
|
|
| def read_rows(path: Path) -> list[dict[str, str]]:
|
| with path.open("r", newline="", encoding="utf-8") as f:
|
| return list(csv.DictReader(f))
|
|
|
|
|
| def sample_per_source(rows: list[dict[str, str]], per_source: int | None, seed: int) -> list[dict[str, str]]:
|
| grouped: dict[str, list[dict[str, str]]] = defaultdict(list)
|
| for row in rows:
|
| grouped[row["source_dataset"]].append(row)
|
| rng = random.Random(seed)
|
| selected = []
|
| for source in sorted(grouped):
|
| source_rows = list(grouped[source])
|
| rng.shuffle(source_rows)
|
| if per_source is not None:
|
| source_rows = source_rows[:per_source]
|
| selected.extend(source_rows)
|
| return selected
|
|
|
|
|
| def make_transform() -> T.Compose:
|
| return T.Compose([
|
| T.Resize(int(224 * 1.15)),
|
| T.CenterCrop(224),
|
| T.ToTensor(),
|
| T.Normalize(CLIP_MEAN, CLIP_STD),
|
| ])
|
|
|
|
|
| @torch.no_grad()
|
| def extract_features(model, loader, device: torch.device) -> tuple[np.ndarray, np.ndarray]:
|
| features = []
|
| labels = []
|
| for images, y in tqdm(loader, desc="Extracting real-source features"):
|
| images = images.to(device)
|
| feat = model.encode_image(images).float()
|
| feat = F.normalize(feat, dim=-1)
|
| features.append(feat.cpu().numpy())
|
| labels.append(y.numpy())
|
| return np.concatenate(features, axis=0), np.concatenate(labels, axis=0)
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description="training real-source bias control.")
|
| parser.add_argument("--real-train-csv", type=Path, default=DEFAULT_SPLIT_DIR / "real_train_pool.csv")
|
| parser.add_argument("--real-val-csv", type=Path, default=DEFAULT_SPLIT_DIR / "real_validation.csv")
|
| parser.add_argument("--train-per-source", type=int, default=5000)
|
| parser.add_argument("--val-per-source", type=int, default=1000)
|
| parser.add_argument("--batch-size", type=int, default=128)
|
| parser.add_argument("--num-workers", type=int, default=8)
|
| parser.add_argument("--device", type=str, default="cuda")
|
| parser.add_argument("--seed", type=int, default=42)
|
| parser.add_argument("--output", type=Path, default=ARTIFACT_ROOT / "results" / "training" / "real_source_bias_clip_logreg.json")
|
| args = parser.parse_args()
|
|
|
| random.seed(args.seed)
|
| np.random.seed(args.seed)
|
| torch.manual_seed(args.seed)
|
| device = torch.device(args.device if torch.cuda.is_available() else "cpu")
|
|
|
| train_rows = sample_per_source(read_rows(args.real_train_csv), args.train_per_source, args.seed)
|
| val_rows = sample_per_source(read_rows(args.real_val_csv), args.val_per_source, args.seed)
|
| labels = sorted({row["source_dataset"] for row in train_rows + val_rows})
|
| label_to_idx = {label: idx for idx, label in enumerate(labels)}
|
| idx_to_label = {idx: label for label, idx in label_to_idx.items()}
|
|
|
| model, _ = clip.load("ViT-L/14", device=device)
|
| model.eval()
|
| transform = make_transform()
|
| train_loader = DataLoader(
|
| RealSourceDataset(train_rows, label_to_idx, transform),
|
| batch_size=args.batch_size,
|
| shuffle=False,
|
| num_workers=args.num_workers,
|
| pin_memory=True,
|
| )
|
| val_loader = DataLoader(
|
| RealSourceDataset(val_rows, label_to_idx, transform),
|
| batch_size=args.batch_size,
|
| shuffle=False,
|
| num_workers=args.num_workers,
|
| pin_memory=True,
|
| )
|
|
|
| x_train, y_train = extract_features(model, train_loader, device)
|
| x_val, y_val = extract_features(model, val_loader, device)
|
| clf = LogisticRegression(max_iter=1000, C=1.0, solver="lbfgs")
|
| clf.fit(x_train, y_train)
|
| pred = clf.predict(x_val)
|
|
|
| report = classification_report(
|
| y_val,
|
| pred,
|
| target_names=[idx_to_label[i] for i in range(len(idx_to_label))],
|
| output_dict=True,
|
| zero_division=0,
|
| )
|
| result = {
|
| "seed": args.seed,
|
| "train_per_source": args.train_per_source,
|
| "val_per_source": args.val_per_source,
|
| "labels": idx_to_label,
|
| "accuracy": float(accuracy_score(y_val, pred)),
|
| "balanced_accuracy": float(balanced_accuracy_score(y_val, pred)),
|
| "classification_report": report,
|
| }
|
| args.output.parent.mkdir(parents=True, exist_ok=True)
|
| with args.output.open("w", encoding="utf-8") as f:
|
| json.dump(result, f, indent=2, ensure_ascii=False)
|
| print(json.dumps(result, indent=2, ensure_ascii=False))
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
