File size: 5,817 Bytes
33c93f7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 | from __future__ import annotations
import json
import random
from contextlib import nullcontext
from pathlib import Path
import torch
from PIL import Image
from torch.nn import functional as F
from torch.utils.data import DataLoader
from .checkpoints import load_checkpoint, save_checkpoint
from .data import ImageDataset, TrainingDataset, load_manifest, pseudo_split
from .losses import nt_xent
from .models import DINOEncoder, SSLModel
from .retrieval import rank_embeddings, rankings, retrieval_metrics, validate_rankings, write_submission
from .transforms import TrainTransforms, deterministic_degrade, inference_transform
@torch.inference_mode()
def encode(model, records, batch_size, device, transform=inference_transform):
loader = DataLoader(ImageDataset(records, transform), batch_size=batch_size, shuffle=False)
ids, batches = [], []
model.eval()
for batch_ids, images in loader:
ids.extend(batch_ids)
batches.append(model(images.to(device)).cpu())
return ids, torch.cat(batches)
@torch.inference_mode()
def evaluate_pseudo(model, train_manifest, data_root, batch_size, device, seed=42):
records = load_manifest(train_manifest, data_root)
_, gallery, query_pairs = pseudo_split(records, seed)
query_records = []
query_tensors = []
for order, (record, degradation_seed) in enumerate(query_pairs):
query_records.append(f"pseudo_q_{order:04d}")
with Image.open(record.path) as image:
query_tensors.append(inference_transform(deterministic_degrade(image, degradation_seed)))
gallery_ids, gallery_features = encode(model, gallery, batch_size, device)
query_features = []
for start in range(0, len(query_tensors), batch_size):
query_features.append(model(torch.stack(query_tensors[start:start + batch_size]).to(device)).cpu())
_, indices = rank_embeddings(torch.cat(query_features), gallery_features)
predictions = rankings(query_records, gallery_ids, indices)
truth = {query_records[i]: record.image_id for i, (record, _) in enumerate(query_pairs)}
return retrieval_metrics(predictions, truth)
def train(args):
random.seed(args.seed)
torch.manual_seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(args.seed)
device = torch.device(args.device)
records = load_manifest(args.train_manifest, args.data_root)
training, _, _ = pseudo_split(records, args.seed)
dataset = TrainingDataset(training, args.method, TrainTransforms())
loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, drop_last=args.method in {"simclr", "joint"})
model = SSLModel(args.method, pretrained=not args.from_scratch).to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-4)
scaler = torch.amp.GradScaler("cuda", enabled=device.type == "cuda")
best = -1.0
config = {key: value for key, value in vars(args).items() if key != "handler"}
for epoch in range(1, args.epochs + 1):
model.train()
total = 0.0
for sample in loader:
optimizer.zero_grad(set_to_none=True)
amp = torch.autocast("cuda", dtype=torch.float16) if device.type == "cuda" else nullcontext()
with amp:
loss = torch.zeros((), device=device)
if args.method in {"simclr", "joint"}:
loss = loss + args.contrastive_weight * nt_xent(model.project(sample["view1"].to(device)), model.project(sample["view2"].to(device)), args.temperature)
if args.method in {"autoencoder", "joint"}:
loss = loss + args.reconstruction_weight * F.mse_loss(model.reconstruct(sample["degraded"].to(device)), sample["clean"].to(device))
if args.method in {"rotation", "joint"}:
loss = loss + args.rotation_weight * F.cross_entropy(model.predict_rotation(sample["rotated"].to(device)), sample["rotation_label"].to(device))
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()
total += float(loss.detach())
metrics = evaluate_pseudo(model.encoder, args.train_manifest, args.data_root, args.batch_size, device, args.seed)
print(json.dumps({"epoch": epoch, "loss": total / len(loader), **metrics}))
if metrics["score"] > best:
best = metrics["score"]
save_checkpoint(args.output, model, args.method, config, epoch, metrics)
def load_encoder(method, checkpoint, device):
if method == "dino":
return DINOEncoder().eval().to(device)
if not checkpoint:
raise ValueError(f"--checkpoint is required for {method}")
model, _ = load_checkpoint(checkpoint, device)
if model.method != method:
raise ValueError(f"Checkpoint method is {model.method}, not {method}")
return model.encoder.eval()
def evaluate(args):
device = torch.device(args.device)
model = load_encoder(args.method, args.checkpoint, device)
print(json.dumps(evaluate_pseudo(model, args.train_manifest, args.data_root, args.batch_size, device, args.seed), indent=2))
def retrieve(args):
device = torch.device(args.device)
model = load_encoder(args.method, args.checkpoint, device)
gallery = load_manifest(args.gallery, args.data_root)
queries = load_manifest(args.queries, args.data_root)
gallery_ids, gallery_features = encode(model, gallery, args.batch_size, device)
query_ids, query_features = encode(model, queries, args.batch_size, device)
_, indices = rank_embeddings(query_features, gallery_features)
predictions = rankings(query_ids, gallery_ids, indices)
validate_rankings(predictions, query_ids, gallery_ids)
write_submission(predictions, args.output)
print(f"saved {args.output}")
|