Upload generate_baselines.py with huggingface_hub

generate_baselines.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+"""
+generate_baselines.py — Generate 3 baseline submission CSV files using CLIP.
+
+Approach 1: Zero-shot ViT-B/32, template "a photo of a {}"
+Approach 2: Zero-shot ViT-B/32 (prompt ensemble) + LogReg linear probe for LP task
+Approach 3: Zero-shot ViT-L/14@336px, template "a photo of a {}"
+
+Outputs: submissions/submission_1_zs_vitb32.csv
+         submissions/submission_2_lp_vitb32.csv
+         submissions/submission_3_zs_vitl14.csv
+         submissions/report.md
+"""
+
+import re
+import time
+from collections import defaultdict
+from pathlib import Path
+
+import clip
+import numpy as np
+import pandas as pd
+import torch
+from PIL import Image
+from sklearn.linear_model import LogisticRegression
+from tqdm import tqdm
+
+DATASET_ROOT = Path('./output/clip-pelatnas-p2')
+SUB_DIR      = Path('./submissions')
+SUB_DIR.mkdir(exist_ok=True)
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"Device: {device}")
+if torch.cuda.is_available():
+    print(f"GPU: {torch.cuda.get_device_name(0)} ({torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB)")
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def load_images_as_tensors(img_dir: Path, fnames: list, preprocess, batch_size=128):
+    """Load images from disk, preprocess, return (N, D) embedding tensor."""
+    imgs = [preprocess(Image.open(img_dir / f).convert('RGB')) for f in tqdm(fnames, desc='  loading')]
+    embeddings = []
+    for i in range(0, len(imgs), batch_size):
+        batch = torch.stack(imgs[i:i + batch_size]).to(device)
+        with torch.no_grad():
+            emb = model.encode_image(batch)
+            emb = emb / emb.norm(dim=-1, keepdim=True)
+        embeddings.append(emb.cpu().float().numpy())
+    return np.vstack(embeddings)
+
+
+def encode_texts(texts: list, batch_size=256):
+    embeddings = []
+    for i in range(0, len(texts), batch_size):
+        batch = clip.tokenize(texts[i:i + batch_size], truncate=True).to(device)
+        with torch.no_grad():
+            emb = model.encode_text(batch)
+            emb = emb / emb.norm(dim=-1, keepdim=True)
+        embeddings.append(emb.cpu().float().numpy())
+    return np.vstack(embeddings)
+
+
+LETTER_MAP = {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E'}
+
+PROMPT_TEMPLATES = [
+    "a photo of a {}",
+    "a photograph of a {}",
+    "a picture of a {}",
+    "an image of a {}",
+    "a {} in the wild",
+    "a photo of the {}",
+    "a {} photo",
+    "a {} image",
+]
+
+
+# ── Per-task inference ────────────────────────────────────────────────────────
+
+def run_zero_shot(class_names, template="a photo of a {}", task='zs'):
+    """Zero-shot classification on ZS or LP test set."""
+    img_dir = DATASET_ROOT / f'test/{"zero_shot" if task == "zs" else "linear_probing"}/images'
+    print(f"\n[Zero-shot task={task}] template: '{template}'")
+    fnames = sorted(f.name for f in img_dir.glob('*.png'))
+
+    embs  = load_images_as_tensors(img_dir, fnames, preprocess)
+    texts = [template.format(c) for c in class_names]
+    text_embs = encode_texts(texts)
+
+    sim  = embs @ text_embs.T          # (N, 10)
+    preds = np.argmax(sim, axis=1)
+    pred_strs = [class_names[i] for i in preds]
+
+    ids = [f'{task}_{i+1:04d}' for i in range(len(fnames))]
+    return ids, pred_strs
+
+
+def run_zero_shot_ensemble(class_names, templates=PROMPT_TEMPLATES, task='zs'):
+    """Zero-shot with ensemble of prompt templates."""
+    img_dir = DATASET_ROOT / f'test/{"zero_shot" if task == "zs" else "linear_probing"}/images'
+    print(f"\n[Zero-shot ensemble task={task}] {len(templates)} templates")
+    fnames = sorted(f.name for f in img_dir.glob('*.png'))
+    embs   = load_images_as_tensors(img_dir, fnames, preprocess)
+
+    # Average text embeddings across templates
+    all_text_embs = []
+    for tmpl in templates:
+        texts = [tmpl.format(c) for c in class_names]
+        te = encode_texts(texts)
+        all_text_embs.append(te)
+    text_embs = np.mean(all_text_embs, axis=0)
+    text_embs = text_embs / np.linalg.norm(text_embs, axis=-1, keepdims=True)
+
+    sim   = embs @ text_embs.T
+    preds = [class_names[i] for i in np.argmax(sim, axis=1)]
+
+    ids = [f'{task}_{i+1:04d}' for i in range(len(fnames))]
+    return ids, preds
+
+
+def run_linear_probe(class_names, template="a photo of a {}"):
+    """Extract LP train embeddings → LogReg → predict LP test."""
+    print(f"\n[Linear probe] C=0.316")
+
+    train_df  = pd.read_csv(DATASET_ROOT / 'train/linear_probing/labels.csv')
+    train_dir = DATASET_ROOT / 'train/linear_probing/images'
+    test_dir  = DATASET_ROOT / 'test/linear_probing/images'
+    test_fnames = sorted(f.name for f in test_dir.glob('*.png'))
+
+    print("  Encoding train images...")
+    train_embs = load_images_as_tensors(train_dir, train_df['image_path'].tolist(), preprocess)
+    train_labels = np.array([class_names.index(l) for l in train_df['label']])
+
+    print("  Encoding test images...")
+    test_embs = load_images_as_tensors(test_dir, test_fnames, preprocess)
+
+    clf = LogisticRegression(max_iter=1000, C=0.316, random_state=42, n_jobs=-1)
+    clf.fit(train_embs, train_labels)
+    preds = [class_names[i] for i in clf.predict(test_embs)]
+
+    ids = [f'lp_{i+1:04d}' for i in range(len(test_fnames))]
+    return ids, preds
+
+
+def run_retrieval():
+    """4-way image-to-text retrieval."""
+    print("\n[Retrieval]")
+    cand_df   = pd.read_csv(DATASET_ROOT / 'test/retrieval/candidates.csv')
+    query_dir = DATASET_ROOT / 'test/retrieval/queries'
+
+    ids, preds = [], []
+    for _, row in tqdm(cand_df.iterrows(), total=len(cand_df)):
+        img_path = query_dir / row['image_path']
+        img = preprocess(Image.open(img_path).convert('RGB')).unsqueeze(0).to(device)
+
+        captions = [row[f'caption_{i}'] for i in range(4)]
+        tokens   = clip.tokenize(captions, truncate=True).to(device)
+
+        with torch.no_grad():
+            img_emb  = model.encode_image(img)
+            img_emb  = img_emb / img_emb.norm(dim=-1, keepdim=True)
+            txt_embs = model.encode_text(tokens)
+            txt_embs = txt_embs / txt_embs.norm(dim=-1, keepdim=True)
+
+        sims = (img_emb @ txt_embs.T).squeeze().cpu().float().numpy()
+        ids.append(row['id'])
+        preds.append(int(np.argmax(sims)))
+
+    return ids, preds
+
+
+def run_mcqa():
+    """Multiple choice QA."""
+    print("\n[MCQA]")
+    test_df   = pd.read_csv(DATASET_ROOT / 'test/mcqa/test.csv')
+    image_dir = DATASET_ROOT / 'test/mcqa/images'
+
+    ids, preds = [], []
+    for _, row in tqdm(test_df.iterrows(), total=len(test_df)):
+        img_path  = image_dir / row['image_path']
+        n_choices = int(row['num_choices'])
+        choices   = [row[f'choice_{chr(65+i)}'] for i in range(n_choices)]
+        question  = row['question']
+
+        img = preprocess(Image.open(img_path).convert('RGB')).unsqueeze(0).to(device)
+        texts  = [f"Question: {question} Answer: {c}" for c in choices]
+        tokens = clip.tokenize(texts, truncate=True).to(device)
+
+        with torch.no_grad():
+            img_emb  = model.encode_image(img)
+            img_emb  = img_emb / img_emb.norm(dim=-1, keepdim=True)
+            txt_embs = model.encode_text(tokens)
+            txt_embs = txt_embs / txt_embs.norm(dim=-1, keepdim=True)
+
+        sims = (img_emb @ txt_embs.T).squeeze().cpu().float().numpy()
+        ids.append(row['id'])
+        preds.append(LETTER_MAP[int(np.argmax(sims))])
+
+    return ids, preds
+
+
+def compute_accuracy(ids, preds, solution_df):
+    sol_map = dict(zip(solution_df['Id'], solution_df['prediction'].astype(str)))
+    correct = sum(str(p) == sol_map.get(i, '') for i, p in zip(ids, preds))
+    return correct / len(ids)
+
+
+def build_submission(parts):
+    """parts = list of (ids, preds) tuples."""
+    rows = []
+    for ids, preds in parts:
+        for i, p in zip(ids, preds):
+            rows.append({'id': i, 'prediction': str(p)})
+    return pd.DataFrame(rows)
+
+
+def run_approach(name, fn_zs, fn_lp, class_names):
+    """Run all 4 tasks with given functions, return dict of results."""
+    t0 = time.time()
+    results = {}
+    results['zs']   = fn_zs(class_names)
+    results['lp']   = fn_lp(class_names)
+    results['ret']  = run_retrieval()
+    results['mcqa'] = run_mcqa()
+    results['elapsed'] = time.time() - t0
+    return results
+
+
+# ── Main ─────────────────────────────────────────────────────────────────────
+
+if __name__ == '__main__':
+    solution_df = pd.read_csv('./output/solution.csv')
+    with open(DATASET_ROOT / 'class_names.txt') as f:
+        class_names = [l.strip() for l in f if l.strip()]
+    print(f"Classes: {class_names}")
+
+    # ── APPROACH 1: ViT-B/32 zero-shot (standard) ────────────────────────────
+    print("\n" + "=" * 60)
+    print("APPROACH 1: Zero-shot ViT-B/32 (standard template)")
+    print("=" * 60)
+    model, preprocess = clip.load("ViT-B/32", device=device)
+    model.eval()
+
+    r1 = {}
+    r1['zs']   = run_zero_shot(class_names, task='zs')
+    r1['lp']   = run_zero_shot(class_names, task='lp')  # ZS on LP test images
+    r1['ret']  = run_retrieval()
+    r1['mcqa'] = run_mcqa()
+
+    sub1 = build_submission([r1['zs'], r1['lp'], r1['ret'], r1['mcqa']])
+    sub1.to_csv(SUB_DIR / 'submission_1_zs_vitb32.csv', index=False)
+
+    # ── APPROACH 2: ViT-B/32 zero-shot ensemble + LogReg LP ──────────────────
+    print("\n" + "=" * 60)
+    print("APPROACH 2: ViT-B/32 prompt ensemble + LogReg linear probe")
+    print("=" * 60)
+
+    r2 = {}
+    r2['zs']   = run_zero_shot_ensemble(class_names)
+    r2['lp']   = run_linear_probe(class_names)
+    r2['ret']  = run_retrieval()   # same model, same result
+    r2['mcqa'] = run_mcqa()
+
+    sub2 = build_submission([r2['zs'], r2['lp'], r2['ret'], r2['mcqa']])
+    sub2.to_csv(SUB_DIR / 'submission_2_lp_vitb32.csv', index=False)
+
+    # ── APPROACH 3: ViT-L/14@336px zero-shot ─────────────────────────────────
+    print("\n" + "=" * 60)
+    print("APPROACH 3: Zero-shot ViT-L/14@336px (best CLIP model)")
+    print("=" * 60)
+    del model
+    torch.cuda.empty_cache()
+    model, preprocess = clip.load("ViT-L/14@336px", device=device)
+    model.eval()
+
+    r3 = {}
+    r3['zs']   = run_zero_shot_ensemble(class_names)
+    r3['lp']   = run_linear_probe(class_names)
+    r3['ret']  = run_retrieval()
+    r3['mcqa'] = run_mcqa()
+
+    sub3 = build_submission([r3['zs'], r3['lp'], r3['ret'], r3['mcqa']])
+    sub3.to_csv(SUB_DIR / 'submission_3_zs_vitl14.csv', index=False)
+
+    # ── Score report ──────────────────────────────────────────────────────────
+    print("\n" + "=" * 60)
+    print("SCORE REPORT")
+    print("=" * 60)
+
+    approaches = {
+        'Approach 1 — ZS ViT-B/32':          r1,
+        'Approach 2 — LP+Ensemble ViT-B/32': r2,
+        'Approach 3 — ZS ViT-L/14@336px':   r3,
+    }
+    tasks = [('zs', 'Zero-shot'), ('lp', 'Linear probe'), ('ret', 'Retrieval'), ('mcqa', 'MCQA')]
+
+    rows = []
+    for approach_name, r in approaches.items():
+        row = {'Approach': approach_name}
+        total_correct, total_n = 0, 0
+        for task_key, task_name in tasks:
+            ids, preds = r[task_key]
+            acc = compute_accuracy(ids, preds, solution_df)
+            row[task_name] = f'{acc*100:.1f}%'
+            total_correct += sum(str(p) == dict(zip(solution_df['Id'], solution_df['prediction'].astype(str))).get(i, '') for i, p in zip(ids, preds))
+            total_n += len(ids)
+        row['Overall (800)'] = f'{total_correct/total_n*100:.1f}%'
+        rows.append(row)
+
+    report_df = pd.DataFrame(rows)
+    print(report_df.to_string(index=False))
+
+    # Save report.md
+    report_md = f"""# CLIP Pelatnas P2 — Baseline Score Report
+
+**GPU**: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}
+**Date**: Generated by generate_baselines.py
+
+## Accuracy per Task & Approach
+
+{report_df.to_markdown(index=False)}
+
+## Keterangan Approach
+
+| Approach | Zero-shot | Linear Probe | Retrieval | MCQA | Model |
+|----------|-----------|--------------|-----------|------|-------|
+| Approach 1 | template standar | zero-shot (no train data) | CLIP similarity | Q+A template | ViT-B/32 |
+| Approach 2 | prompt ensemble (8 template) | LogReg di CLIP features (C=0.316) | CLIP similarity | Q+A template | ViT-B/32 |
+| Approach 3 | prompt ensemble (8 template) | LogReg di CLIP features | CLIP similarity | Q+A template | ViT-L/14@336px |
+
+## Catatan
+
+- **Zero-shot**: Task 1 — CLIP langsung predict tanpa training
+- **Linear Probe**: Task 2 — LogReg trained di atas CLIP embeddings (1000 labeled images)
+- **Retrieval**: 4-way image-to-text matching, random baseline = 25%
+- **MCQA**: Visual QA dari ScienceQA, random baseline ≈ 28% (~3.5 avg choices)
+
+## Baseline untuk Peserta
+
+Approach 1 adalah baseline yang akan ditunjukkan di tutorial notebook.
+Approach 2 dan 3 adalah referensi untuk mengetahui "ceiling" skor yang realistis.
+"""
+
+    with open(SUB_DIR / 'report.md', 'w') as f:
+        f.write(report_md)
+
+    print(f"\nFiles saved to {SUB_DIR.absolute()}/")
+    print("  submission_1_zs_vitb32.csv")
+    print("  submission_2_lp_vitb32.csv")
+    print("  submission_3_zs_vitl14.csv")
+    print("  report.md")