#!/usr/bin/env python3
"""
create_notebook.py — Generate clip_tutorial.ipynb

Run this script to produce the tutorial notebook for the CLIP Pelatnas P2 competition.
Requires: nbformat (included with jupyter)
"""

import nbformat as nbf

nb = nbf.v4.new_notebook()
nb.metadata = {
    "kernelspec": {
        "display_name": "Python 3",
        "language": "python",
        "name": "python3"
    },
    "language_info": {
        "name": "python",
        "version": "3.10.0"
    }
}

cells = []

def md(source): cells.append(nbf.v4.new_markdown_cell(source))
def code(source): cells.append(nbf.v4.new_code_cell(source))


# ─────────────────────────────────────────────────────────────────────────────
# Header
# ─────────────────────────────────────────────────────────────────────────────

md("""\
# CLIP Tutorial — Pelatnas IOAI 2026 P2

**Topik:** Multimodal Learning — CLIP (Contrastive Language-Image Pretraining)

Notebook ini memandu kalian dari nol — memahami arsitektur CLIP, mengimplementasikannya dari scratch,
sampai menggunakannya untuk menyelesaikan 4 task kompetisi ARIA.

| Section | Topik |
|---------|-------|
| 1 | CLIP: Arsitektur dan Motivasi |
| 2 | Mini CLIP dari Scratch (CIFAR-10) |
| 3 | Load Pretrained CLIP + Eksplorasi Embedding Space |
| 4 | Zero-Shot Classification |
| 5 | Linear Probing |
| 6 | Image-Text Retrieval |
| 7 | MCQA dengan CLIP |
| 8 | Baseline Submission |
""")


# ─────────────────────────────────────────────────────────────────────────────
# Section 1 — CLIP Architecture
# ─────────────────────────────────────────────────────────────────────────────

md("""\
---
## Section 1 — CLIP: Arsitektur dan Motivasi

### Mengapa CLIP?

Model vision konvensional (ResNet, ViT) ditraining untuk memprediksi label dari
dataset yang fixed (ImageNet → 1000 kelas). Masalahnya:
- Tidak bisa generalize ke kelas baru tanpa retraining
- Label harus predefined, tidak bisa deskripsi bebas

**CLIP** (Contrastive Language-Image Pretraining, Radford et al. 2021) menyelesaikan
ini dengan cara berbeda: instead of predicting labels, CLIP belajar *alignment*
antara gambar dan teks.

### Dual-Stream Architecture

CLIP terdiri dari dua encoder yang ditraining bersama:
1. **Image Encoder**: ViT atau ResNet → menghasilkan image embedding (vektor)
2. **Text Encoder**: Transformer → menghasilkan text embedding (vektor)

Kedua encoder memproyeksikan input ke *shared embedding space* dengan dimensi
yang sama (e.g., 512 untuk ViT-B/32).

### Training Objective

CLIP ditraining dengan dataset **400 juta** pasang (image, caption) dari internet.
Objective-nya sederhana:
- image dan caption yang **matching** → cosine similarity **TINGGI**
- image dan caption yang **tidak matching** → cosine similarity **RENDAH**

Ini adalah *contrastive learning*: model belajar "mendekatkan" pasangan yang benar
dan "menjauhkan" pasangan yang salah.
""")

code("""\
# ── Cell 1.1: Visualisasi konsep similarity matrix ──────────────────────────
import numpy as np
import matplotlib.pyplot as plt

labels = ['cat', 'dog', 'car', 'ship', 'bird', 'horse']
N = len(labels)

# Similarity matrix ideal: diagonal tinggi, off-diagonal rendah
np.random.seed(42)
sim_matrix = np.random.uniform(0.1, 0.4, (N, N))
np.fill_diagonal(sim_matrix, np.random.uniform(0.8, 0.95, N))

fig, ax = plt.subplots(figsize=(7, 6))
im = ax.imshow(sim_matrix, cmap='Blues', vmin=0, vmax=1)
ax.set_xticks(range(N))
ax.set_yticks(range(N))
ax.set_xticklabels([f'"{l}"' for l in labels], rotation=45, ha='right')
ax.set_yticklabels([f'[IMG {l}]' for l in labels])
ax.set_xlabel('Text Embeddings')
ax.set_ylabel('Image Embeddings')
ax.set_title('CLIP Similarity Matrix\\n(diagonal = matching pairs)')
plt.colorbar(im)

for i in range(N):
    for j in range(N):
        ax.text(j, i, f'{sim_matrix[i, j]:.2f}',
                ha='center', va='center',
                color='white' if sim_matrix[i, j] > 0.6 else 'black', fontsize=9)
plt.tight_layout()
plt.show()
""")


# ─────────────────────────────────────────────────────────────────────────────
# Section 2 — Mini CLIP from Scratch
# ─────────────────────────────────────────────────────────────────────────────

md("""\
---
## Section 2 — Mini CLIP dari Scratch

### Implementasi CLIP dari Nol

Kita akan membuat versi miniatur CLIP untuk memahami mekanismenya.
Ini **BUKAN** untuk performa — hanya untuk intuisi.

Dataset toy: CIFAR-10 subset (1.000 images, 10 classes).
Template caption: `"a photo of a {class_name}"`.

Komponen yang diperlukan:
1. `TinyImageEncoder`: CNN sederhana → embedding
2. `TinyTextEncoder`: word embedding → pooling → linear
3. `InfoNCE Loss`: fungsi loss contrastive
4. Training loop + visualisasi
""")

code("""\
# ── Cell 2.1: Setup dan download CIFAR-10 ───────────────────────────────────
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data import DataLoader, Subset
import numpy as np

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"Using device: {device}")

CIFAR10_CLASSES = ['airplane', 'automobile', 'bird', 'cat', 'deer',
                   'dog', 'frog', 'horse', 'ship', 'truck']

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

full_train = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)

# Ambil 100 images per class = 1000 total
indices_per_class = {c: [] for c in range(10)}
for idx, (_, label) in enumerate(full_train):
    if len(indices_per_class[label]) < 100:
        indices_per_class[label].append(idx)
    if all(len(v) == 100 for v in indices_per_class.values()):
        break

all_indices = [idx for idxs in indices_per_class.values() for idx in idxs]
toy_labels  = [full_train.targets[i] for i in all_indices]
toy_dataset = Subset(full_train, all_indices)

print(f"Toy dataset size: {len(toy_dataset)} images")
""")

code("""\
# ── Cell 2.2: Tiny Image Encoder ────────────────────────────────────────────
class TinyImageEncoder(nn.Module):
    \"\"\"
    CNN sederhana: Conv → ReLU → MaxPool (×2) → GAP → Linear projection
    Input: (B, 3, 32, 32)
    Output: (B, EMBED_DIM) — normalized embedding
    \"\"\"
    def __init__(self, embed_dim=128):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),   # → (B, 32, 32, 32)
            nn.ReLU(),
            nn.MaxPool2d(2),                               # → (B, 32, 16, 16)
            nn.Conv2d(32, 64, kernel_size=3, padding=1),  # → (B, 64, 16, 16)
            nn.ReLU(),
            nn.MaxPool2d(2),                               # → (B, 64, 8, 8)
        )
        self.projection = nn.Linear(64, embed_dim)

    def forward(self, x):
        x = self.conv(x)
        x = x.mean(dim=[2, 3])           # Global Average Pooling → (B, 64)
        x = self.projection(x)           # (B, embed_dim)
        return F.normalize(x, dim=-1)    # L2-normalize → unit sphere


# ── Cell 2.3: Tiny Text Encoder ─────────────────────────────────────────────
class TinyTextEncoder(nn.Module):
    \"\"\"
    Word embedding → mean pooling → Linear projection
    Input: token ids (B, seq_len)
    Output: (B, EMBED_DIM) — normalized embedding
    \"\"\"
    def __init__(self, vocab_size, embed_dim=128, hidden_dim=64):
        super().__init__()
        self.embedding  = nn.Embedding(vocab_size, hidden_dim, padding_idx=0)
        self.projection = nn.Linear(hidden_dim, embed_dim)

    def forward(self, x):
        emb    = self.embedding(x)    # (B, seq_len, hidden_dim)
        pooled = emb.mean(dim=1)      # mean pooling → (B, hidden_dim)
        out    = self.projection(pooled)
        return F.normalize(out, dim=-1)
""")

code("""\
# ── Cell 2.4: Simple Tokenizer ───────────────────────────────────────────────
templates = [f"a photo of a {c}" for c in CIFAR10_CLASSES]
all_words  = set()
for t in templates:
    all_words.update(t.split())
vocab = {word: idx + 1 for idx, word in enumerate(sorted(all_words))}
vocab['<pad>'] = 0


def tokenize(text, max_len=8):
    tokens = [vocab.get(w, 0) for w in text.split()]
    tokens = tokens[:max_len]
    tokens += [0] * (max_len - len(tokens))
    return tokens


text_tokens = torch.tensor([tokenize(t) for t in templates]).to(device)  # (10, 8)
vocab_size  = len(vocab) + 1

print("Vocabulary:", vocab)
print("Template tokens shape:", text_tokens.shape)
""")

code("""\
# ── Cell 2.5: InfoNCE Loss ───────────────────────────────────────────────────
def info_nce_loss(image_emb, text_emb, temperature=0.07):
    \"\"\"
    Contrastive loss untuk batch of N image-text pairs.

    Intuisi:
      - Hitung similarity matrix N×N
      - Untuk setiap image, correct text-nya adalah di posisi diagonal
      - Cross-entropy: dorong diagonal jadi paling tinggi
      - Loss = rata-rata dua arah (image→text + text→image)
    \"\"\"
    logits = (image_emb @ text_emb.T) / temperature    # (N, N)
    labels = torch.arange(len(image_emb)).to(image_emb.device)

    loss_i2t = F.cross_entropy(logits,   labels)
    loss_t2i = F.cross_entropy(logits.T, labels)

    return (loss_i2t + loss_t2i) / 2
""")

code("""\
# ── Cell 2.6: TinyCLIP model ────────────────────────────────────────────────
class TinyCLIP(nn.Module):
    def __init__(self, vocab_size, embed_dim=128):
        super().__init__()
        self.image_encoder = TinyImageEncoder(embed_dim)
        self.text_encoder  = TinyTextEncoder(vocab_size, embed_dim)

    def encode_image(self, images):
        return self.image_encoder(images)

    def encode_text(self, tokens):
        return self.text_encoder(tokens)


model = TinyCLIP(vocab_size=vocab_size, embed_dim=128).to(device)
print(f"TinyCLIP parameters: {sum(p.numel() for p in model.parameters()):,}")
""")

code("""\
# ── Cell 2.7: Training loop ──────────────────────────────────────────────────
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

images_tensor = torch.stack([toy_dataset[i][0] for i in range(len(toy_dataset))])
loader = DataLoader(
    list(zip(images_tensor, toy_labels)),
    batch_size=64, shuffle=True
)

loss_history = []
NUM_EPOCHS   = 10

for epoch in range(NUM_EPOCHS):
    model.train()
    epoch_losses = []

    for images, labels in loader:
        images = images.to(device)
        labels_list = labels.tolist() if isinstance(labels, torch.Tensor) else labels

        batch_text = text_tokens[labels_list]          # (B, 8)
        image_emb  = model.encode_image(images)        # (B, 128)
        text_emb   = model.encode_text(batch_text)     # (B, 128)

        loss = info_nce_loss(image_emb, text_emb)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        epoch_losses.append(loss.item())

    mean_loss = np.mean(epoch_losses)
    loss_history.append(mean_loss)
    print(f"Epoch {epoch+1:2d}/{NUM_EPOCHS} | Loss: {mean_loss:.4f}")
""")

code("""\
# ── Cell 2.8: Plot loss curve ────────────────────────────────────────────────
import matplotlib.pyplot as plt

plt.figure(figsize=(8, 4))
plt.plot(range(1, NUM_EPOCHS + 1), loss_history, marker='o', linewidth=2, color='steelblue')
plt.xlabel('Epoch')
plt.ylabel('InfoNCE Loss')
plt.title('TinyCLIP Training Loss')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
""")

code("""\
# ── Cell 2.9: Visualisasi embedding space (t-SNE) ───────────────────────────
from sklearn.manifold import TSNE

model.eval()
with torch.no_grad():
    all_images  = torch.stack([toy_dataset[i][0] for i in range(len(toy_dataset))]).to(device)
    image_embs  = model.encode_image(all_images).cpu().numpy()
    text_embs   = model.encode_text(text_tokens).cpu().numpy()

all_embs = np.vstack([image_embs, text_embs])  # (1010, 128)
tsne     = TSNE(n_components=2, random_state=42, perplexity=30)
embs_2d  = tsne.fit_transform(all_embs)

img_2d = embs_2d[:1000]
txt_2d = embs_2d[1000:]

colors = plt.cm.tab10(np.linspace(0, 1, 10))
fig, ax = plt.subplots(figsize=(10, 8))

for c in range(10):
    mask = np.array(toy_labels) == c
    ax.scatter(img_2d[mask, 0], img_2d[mask, 1],
               c=[colors[c]], alpha=0.4, s=20, label=CIFAR10_CLASSES[c])
    ax.scatter(txt_2d[c, 0], txt_2d[c, 1],
               c=[colors[c]], marker='*', s=300, edgecolors='black', linewidths=1)

ax.legend(loc='upper right', fontsize=8)
ax.set_title('t-SNE: TinyCLIP Embedding Space\\n'
             '(dots = images, stars = text templates)')
ax.axis('off')
plt.tight_layout()
plt.show()
""")


# ─────────────────────────────────────────────────────────────────────────────
# Section 3 — Load Pretrained CLIP
# ─────────────────────────────────────────────────────────────────────────────

md("""\
---
## Section 3 — Load Pretrained CLIP + Eksplorasi Embedding Space

### Dari Scratch ke Pretrained

TinyCLIP kita ditraining di 1.000 gambar selama beberapa menit.
CLIP asli ditraining di **400 juta** pasang selama berbulan-bulan di ratusan GPU.

Hasilnya sangat berbeda. Mari kita load pretrained CLIP dan lihat embedding space-nya.

**`openai/clip-vit-b-32`:**
- Image encoder: Vision Transformer ViT-B/32
- Text encoder: Transformer 12 layers
- Embedding dim: 512
- Total parameters: ~150M
""")

code("""\
# ── Cell 3.1: Install dan load CLIP ─────────────────────────────────────────
# !pip install git+https://github.com/openai/CLIP.git  # jalankan sekali jika belum

import clip
from PIL import Image
import torch
import numpy as np
import matplotlib.pyplot as plt

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model_clip, preprocess = clip.load("ViT-B/32", device=device)
model_clip.eval()

print(f"Model loaded. Input resolution: {model_clip.visual.input_resolution}")
print(f"Embedding dimension: {model_clip.visual.output_dim}")
""")

code("""\
# ── Cell 3.2: Load STL-10 test images ───────────────────────────────────────
from torchvision import datasets
from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize

clip_preprocess = Compose([
    Resize(224),
    CenterCrop(224),
    ToTensor(),
    Normalize((0.48145466, 0.4578275, 0.40821073),
              (0.26862954, 0.26130258, 0.27577711))
])

stl10_test = datasets.STL10(root='./data', split='test', download=True,
                             transform=clip_preprocess)

STL10_CLASSES = stl10_test.classes
print(f"STL-10 classes: {STL10_CLASSES}")

# Ambil 20/class untuk zero-shot (200 total) dan 20/class untuk linear probing (200 total)
from collections import defaultdict
zs_imgs, zs_labels = [], []
lp_imgs, lp_labels = [], []
zs_count  = defaultdict(int)
lp_count  = defaultdict(int)

for idx in range(len(stl10_test)):
    img, label = stl10_test[idx]
    if zs_count[label] < 20:
        zs_imgs.append(img)
        zs_labels.append(label)
        zs_count[label] += 1
    elif lp_count[label] < 20:
        lp_imgs.append(img)
        lp_labels.append(label)
        lp_count[label] += 1
    if sum(zs_count.values()) == 200 and sum(lp_count.values()) == 200:
        break

zs_labels_arr = np.array(zs_labels)
lp_test_labels = np.array(lp_labels)
print(f"ZS set: {len(zs_imgs)} | LP test set: {len(lp_imgs)}")
""")

code("""\
# ── Cell 3.3: Extract CLIP image embeddings ──────────────────────────────────
from torch.utils.data import DataLoader, TensorDataset


def extract_embeddings(img_list, batch_size=64):
    \"\"\"Extract CLIP image embeddings dari list of tensors.\"\"\"
    all_embs = []
    for i in range(0, len(img_list), batch_size):
        batch = torch.stack(img_list[i:i + batch_size]).to(device)
        with torch.no_grad():
            emb = model_clip.encode_image(batch)
            emb = emb / emb.norm(dim=-1, keepdim=True)
        all_embs.append(emb.cpu())
    return torch.cat(all_embs).numpy()


print("Extracting embeddings...")
zs_embeddings       = extract_embeddings(zs_imgs)
lp_test_embeddings  = extract_embeddings(lp_imgs)

print(f"Zero-shot embeddings: {zs_embeddings.shape}")
print(f"Linear probing test embeddings: {lp_test_embeddings.shape}")
""")

code("""\
# ── Cell 3.4: Extract text embeddings untuk 10 kelas ────────────────────────
def get_text_embeddings(class_names, template="a photo of a {}"):
    \"\"\"Encode class names dengan text encoder CLIP.\"\"\"
    prompts = [template.format(c) for c in class_names]
    tokens  = clip.tokenize(prompts).to(device)
    with torch.no_grad():
        text_emb = model_clip.encode_text(tokens)
        text_emb = text_emb / text_emb.norm(dim=-1, keepdim=True)
    return text_emb.cpu().numpy()


text_embeddings = get_text_embeddings(STL10_CLASSES)
print(f"Text embeddings: {text_embeddings.shape}")   # (10, 512)
""")

code("""\
# ── Cell 3.5: Visualisasi t-SNE ─────────────────────────────────────────────
from sklearn.manifold import TSNE

all_embs = np.vstack([zs_embeddings, text_embeddings])   # (210, 512)
tsne     = TSNE(n_components=2, random_state=42, perplexity=30)
embs_2d  = tsne.fit_transform(all_embs)

img_2d = embs_2d[:200]
txt_2d = embs_2d[200:]

colors = plt.cm.tab10(np.linspace(0, 1, 10))
fig, ax = plt.subplots(figsize=(12, 9))

for c in range(10):
    mask = zs_labels_arr == c
    ax.scatter(img_2d[mask, 0], img_2d[mask, 1],
               c=[colors[c]], alpha=0.5, s=30, label=STL10_CLASSES[c])
    ax.scatter(txt_2d[c, 0], txt_2d[c, 1],
               c=[colors[c]], marker='*', s=500, edgecolors='black', linewidths=1.5)

ax.legend(loc='upper right', fontsize=9)
ax.set_title('Pretrained CLIP — Embedding Space (STL-10)\\n'
             'Dots = image embeddings | Stars = text template embeddings', fontsize=12)
ax.axis('off')
plt.tight_layout()
plt.show()
""")


# ─────────────────────────────────────────────────────────────────────────────
# Section 4 — Zero-Shot Classification
# ─────────────────────────────────────────────────────────────────────────────

md("""\
---
## Section 4 — Zero-Shot Classification

### Cara Kerja Zero-Shot dengan CLIP

1. Encode setiap class name menjadi text embedding
2. Encode query image menjadi image embedding
3. Hitung cosine similarity antara image dan semua class embeddings
4. Prediksi = class dengan similarity tertinggi

**Prompt engineering penting!**
`"dog"` ≠ `"a photo of a dog"` ≠ `"a high-quality photo of a dog, DSLR"`
""")

code("""\
# ── Cell 4.1: Zero-shot prediction ──────────────────────────────────────────
# zs_embeddings dan text_embeddings sudah dihitung di Section 3

similarity     = zs_embeddings @ text_embeddings.T    # (200, 10)
predictions_idx = np.argmax(similarity, axis=1)
predictions_str = [STL10_CLASSES[i] for i in predictions_idx]

accuracy = np.mean(predictions_idx == zs_labels_arr)
print(f"Zero-shot accuracy: {accuracy:.4f} ({accuracy*100:.1f}%)")
""")

code("""\
# ── Cell 4.2: Pengaruh prompt engineering ────────────────────────────────────
templates_to_compare = [
    "{}",
    "a photo of a {}",
    "a photo of a {}, high quality",
    "a {} in the wild",
]

print("\\nPrompt engineering comparison:")
print("-" * 50)
for template in templates_to_compare:
    text_emb = get_text_embeddings(STL10_CLASSES, template)
    sim      = zs_embeddings @ text_emb.T
    preds    = np.argmax(sim, axis=1)
    acc      = np.mean(preds == zs_labels_arr)
    print(f"  {template:<40} → {acc*100:.1f}%")
""")

code("""\
# ── Cell 4.3: Confusion matrix ───────────────────────────────────────────────
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

cm   = confusion_matrix(zs_labels_arr, predictions_idx)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=STL10_CLASSES)

fig, ax = plt.subplots(figsize=(10, 8))
disp.plot(ax=ax, colorbar=False, cmap='Blues')
ax.set_title('Zero-Shot Classification — Confusion Matrix')
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()
""")

code("""\
# ── Cell 4.4: Per-class accuracy ─────────────────────────────────────────────
per_class_acc = {}
for c in range(10):
    mask = zs_labels_arr == c
    per_class_acc[STL10_CLASSES[c]] = np.mean(predictions_idx[mask] == c)

print("\\nPer-class accuracy:")
for cls, acc in sorted(per_class_acc.items(), key=lambda x: -x[1]):
    bar = '█' * int(acc * 20)
    print(f"  {cls:<10} {acc*100:5.1f}% {bar}")
""")


# ─────────────────────────────────────────────────────────────────────────────
# Section 5 — Linear Probing
# ─────────────────────────────────────────────────────────────────────────────

md("""\
---
## Section 5 — Linear Probing

### Perbedaan dari Zero-Shot

| Metode | Data berlabel? | Cara prediksi |
|--------|---------------|---------------|
| Zero-shot | Tidak | Text prompts |
| Linear probing | Ya (sedikit) | Classifier di atas frozen embeddings |

**Kenapa tidak fine-tune semua layer?**
- Linear probing murah secara komputasi
- Menguji seberapa "baik" embeddings CLIP tanpa tambahan supervision
- Fine-tuning bisa overfit ke domain kecil
""")

code("""\
# ── Cell 5.1: Extract train embeddings untuk linear probing ─────────────────
stl10_train = datasets.STL10(root='./data', split='train', download=True,
                              transform=clip_preprocess)

# Ambil 100/class = 1000 images untuk training
train_imgs, train_labels = [], []
count = defaultdict(int)

for idx in range(len(stl10_train)):
    img, label = stl10_train[idx]
    if count[label] < 100:
        train_imgs.append(img)
        train_labels.append(label)
        count[label] += 1
    if sum(count.values()) == 1000:
        break

train_labels_arr = np.array(train_labels)
print("Extracting train embeddings...")
lp_train_embeddings = extract_embeddings(train_imgs)
print(f"Train embeddings: {lp_train_embeddings.shape}")
""")

code("""\
# ── Cell 5.2: Train classifier ───────────────────────────────────────────────
from sklearn.linear_model import LogisticRegression

clf = LogisticRegression(max_iter=1000, C=0.316, random_state=42)
clf.fit(lp_train_embeddings, train_labels_arr)

lp_predictions = clf.predict(lp_test_embeddings)
lp_accuracy    = np.mean(lp_predictions == lp_test_labels)
print(f"Linear probing accuracy: {lp_accuracy:.4f} ({lp_accuracy*100:.1f}%)")
""")

code("""\
# ── Cell 5.3: Perbandingan zero-shot vs linear probing ───────────────────────
print("\\n" + "="*50)
print("  Perbandingan: Zero-Shot vs Linear Probing")
print("="*50)
print(f"  Zero-shot    (0 training images)  : {accuracy*100:5.1f}%")
print(f"  Linear probe (1.000 labeled imgs) : {lp_accuracy*100:5.1f}%")
print(f"  Gap: +{(lp_accuracy - accuracy)*100:.1f}%")
print("="*50)
""")

code("""\
# ── Cell 5.4: Bar chart per-class comparison ─────────────────────────────────
per_class_lp = {}
for c in range(10):
    mask = lp_test_labels == c
    per_class_lp[STL10_CLASSES[c]] = np.mean(lp_predictions[mask] == c)

fig, ax = plt.subplots(figsize=(12, 5))
x = np.arange(10)
w = 0.35
zs_vals = [per_class_acc[c] for c in STL10_CLASSES]
lp_vals = [per_class_lp[c]  for c in STL10_CLASSES]

ax.bar(x - w/2, zs_vals, w, label='Zero-shot',    color='steelblue', alpha=0.8)
ax.bar(x + w/2, lp_vals, w, label='Linear probe', color='coral',     alpha=0.8)
ax.set_xticks(x)
ax.set_xticklabels(STL10_CLASSES, rotation=45, ha='right')
ax.set_ylabel('Accuracy')
ax.set_title('Per-Class Accuracy: Zero-Shot vs Linear Probing')
ax.legend()
ax.set_ylim(0, 1.05)
ax.grid(True, axis='y', alpha=0.3)
plt.tight_layout()
plt.show()
""")


# ─────────────────────────────────────────────────────────────────────────────
# Section 6 — Image-Text Retrieval
# ─────────────────────────────────────────────────────────────────────────────

md("""\
---
## Section 6 — Image-Text Retrieval

### Retrieval sebagai Task Matching

CLIP sangat natural untuk retrieval:
1. Encode query image → image embedding
2. Encode semua candidate captions → text embeddings
3. Similarity = cosine similarity
4. Predict = candidate dengan similarity tertinggi

Dalam competition: **4 candidates per query**, predict index 0–3.
""")

code("""\
# ── Cell 6.1: Load Flickr8k test data ────────────────────────────────────────
import pandas as pd
from PIL import Image as PILImage

DATASET_ROOT = '/kaggle/input/clip-pelatnas-p2'
candidates_df = pd.read_csv(f'{DATASET_ROOT}/test/retrieval/candidates.csv')
print(f"Retrieval test: {len(candidates_df)} queries")
print(candidates_df.head(2))
""")

code("""\
# ── Cell 6.2: CLIP retrieval pipeline ────────────────────────────────────────
def clip_retrieval(image_path, captions, model, preprocess, device):
    \"\"\"
    Predict correct caption index untuk satu query.
    Returns: (predicted_idx, similarities_array)
    \"\"\"
    image = preprocess(PILImage.open(image_path)).unsqueeze(0).to(device)
    with torch.no_grad():
        img_emb = model.encode_image(image)
        img_emb = img_emb / img_emb.norm(dim=-1, keepdim=True)

    tokens = clip.tokenize(captions, truncate=True).to(device)
    with torch.no_grad():
        txt_emb = model.encode_text(tokens)
        txt_emb = txt_emb / txt_emb.norm(dim=-1, keepdim=True)

    similarities  = (img_emb @ txt_emb.T).squeeze().cpu().numpy()
    predicted_idx = int(np.argmax(similarities))
    return predicted_idx, similarities
""")

code("""\
# ── Cell 6.3: Batch evaluation ────────────────────────────────────────────────
base_path = f'{DATASET_ROOT}/test/retrieval/queries/'
predictions_ret = []

for _, row in candidates_df.iterrows():
    captions  = [row[f'caption_{i}'] for i in range(4)]
    pred_idx, _ = clip_retrieval(
        base_path + row['image_path'], captions, model_clip, preprocess, device
    )
    predictions_ret.append(pred_idx)

predictions_ret = np.array(predictions_ret)
correct_idx     = candidates_df['correct_idx'].values

ret_accuracy = np.mean(predictions_ret == correct_idx)
print(f"Retrieval accuracy (4-way): {ret_accuracy:.4f} ({ret_accuracy*100:.1f}%)")
print(f"Random baseline: 25.0%")
""")

code("""\
# ── Cell 6.4: Qualitative examples ───────────────────────────────────────────
fig, axes = plt.subplots(2, 4, figsize=(16, 7))
correct_mask     = predictions_ret == correct_idx
correct_examples = np.where(correct_mask)[0][:2]
wrong_examples   = np.where(~correct_mask)[0][:2]
examples         = list(correct_examples) + list(wrong_examples)

for col, idx in enumerate(examples):
    row_data = candidates_df.iloc[idx]
    captions = [row_data[f'caption_{i}'] for i in range(4)]
    _, sims  = clip_retrieval(
        base_path + row_data['image_path'], captions, model_clip, preprocess, device
    )

    img = PILImage.open(base_path + row_data['image_path'])
    axes[0, col].imshow(img)
    axes[0, col].set_title('Benar' if col < 2 else 'Salah',
                           color='green' if col < 2 else 'red', fontsize=12)
    axes[0, col].axis('off')

    for i, (cap, sim) in enumerate(zip(captions, sims)):
        is_correct = (i == row_data['correct_idx'])
        is_wrong   = (i == predictions_ret[idx] and not is_correct)
        color  = 'green' if is_correct else ('red' if is_wrong else 'black')
        marker = '★' if is_correct else ('✗' if is_wrong else '  ')
        axes[1, col].text(0.02, 0.88 - i * 0.23,
                          f"{marker} [{sim:.2f}] {cap[:55]}...",
                          transform=axes[1, col].transAxes,
                          fontsize=7, color=color)
    axes[1, col].axis('off')

plt.suptitle('Retrieval Examples (★ = correct answer, ✗ = wrong prediction)', fontsize=12)
plt.tight_layout()
plt.show()
""")


# ─────────────────────────────────────────────────────────────────────────────
# Section 7 — MCQA
# ─────────────────────────────────────────────────────────────────────────────

md("""\
---
## Section 7 — MCQA dengan CLIP

### Keterbatasan CLIP untuk Reasoning

Cara naive dengan CLIP:
- Encode image
- Untuk setiap pilihan jawaban: encode `"Question: {q} Answer: {choice}"`
- Predict = pilihan dengan similarity tertinggi terhadap image

**Limitation**: CLIP tidak didesain untuk reasoning bertahap.
CLIP bagus di *"apa yang ada di gambar ini?"* tapi terbatas untuk
*"kenapa hal ini terjadi?"* atau soal sains yang butuh domain knowledge.
""")

code("""\
# ── Cell 7.1: Load ScienceQA test data ──────────────────────────────────────
mcqa_df = pd.read_csv(f'{DATASET_ROOT}/test/mcqa/test.csv')
print(f"MCQA test: {len(mcqa_df)} questions")
print(mcqa_df.head(2))
""")

code("""\
# ── Cell 7.2: CLIP MCQA pipeline ─────────────────────────────────────────────
def clip_mcqa(image_path, question, choices, model, preprocess, device):
    \"\"\"
    Predict correct answer untuk MCQA.
    Strategi: encode image, bandingkan dengan "Question: {q} Answer: {choice}".
    \"\"\"
    image = preprocess(PILImage.open(image_path)).unsqueeze(0).to(device)
    with torch.no_grad():
        img_emb = model.encode_image(image)
        img_emb = img_emb / img_emb.norm(dim=-1, keepdim=True)

    texts  = [f"Question: {question} Answer: {c}" for c in choices]
    tokens = clip.tokenize(texts, truncate=True).to(device)
    with torch.no_grad():
        txt_emb = model.encode_text(tokens)
        txt_emb = txt_emb / txt_emb.norm(dim=-1, keepdim=True)

    similarities  = (img_emb @ txt_emb.T).squeeze().cpu().numpy()
    predicted_idx = int(np.argmax(similarities))

    letter_map = {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E'}
    return letter_map[predicted_idx], similarities
""")

code("""\
# ── Cell 7.3: Batch evaluation ────────────────────────────────────────────────
base_path_mcqa = f'{DATASET_ROOT}/test/mcqa/images/'
predictions_mcqa = []

for _, row in mcqa_df.iterrows():
    n_choices = int(row['num_choices'])
    choices   = [row[f'choice_{chr(65+i)}'] for i in range(n_choices)]

    pred_letter, _ = clip_mcqa(
        base_path_mcqa + row['image_path'],
        row['question'], choices, model_clip, preprocess, device
    )
    predictions_mcqa.append(pred_letter)

mcqa_accuracy = np.mean(np.array(predictions_mcqa) == mcqa_df.get('answer', pd.Series([])).values) \
    if 'answer' in mcqa_df.columns else float('nan')

print(f"MCQA accuracy: {mcqa_accuracy:.4f} ({mcqa_accuracy*100:.1f}%)" if not np.isnan(mcqa_accuracy)
      else "MCQA predictions done (answer column not available in test set)")
print(f"Random baseline (~3.5 choices avg): ~{100/3.5:.1f}%")
""")

code("""\
# ── Cell 7.4: Analysis per subject ───────────────────────────────────────────
mcqa_df_copy = mcqa_df.copy()
mcqa_df_copy['predicted'] = predictions_mcqa

if 'subject' in mcqa_df_copy.columns and 'answer' in mcqa_df_copy.columns:
    mcqa_df_copy['correct'] = mcqa_df_copy['predicted'] == mcqa_df_copy['answer']
    subject_acc = mcqa_df_copy.groupby('subject')['correct'].mean().sort_values(ascending=False)

    print("Accuracy per subject:")
    for subj, acc in subject_acc.items():
        bar = '█' * int(acc * 20)
        print(f"  {subj:<25} {acc*100:5.1f}% {bar}")
else:
    subj_counts = mcqa_df_copy.groupby('subject')['predicted'].count()
    print("Question count per subject:")
    for subj, cnt in subj_counts.items():
        print(f"  {subj:<25} {cnt} questions")
""")


# ─────────────────────────────────────────────────────────────────────────────
# Section 8 — Baseline Submission
# ─────────────────────────────────────────────────────────────────────────────

md("""\
---
## Section 8 — Baseline Submission

### Membuat Submission

Kode berikut menggabungkan prediksi dari semua 4 task ke dalam satu CSV.
Ini adalah baseline paling sederhana: semua task menggunakan zero-shot CLIP.

**Estimasi skor baseline: ~70–80% overall accuracy.**

Cara improve:
- Prompt engineering yang lebih baik
- Gunakan model CLIP yang lebih besar (ViT-L/14)
- Fine-tuning CLIP untuk task tertentu
- Ensemble dengan model multimodal lain (BLIP, SigLIP)
""")

code("""\
# ── Cell 8.1: Compile semua prediksi ─────────────────────────────────────────
import pandas as pd

sample_sub = pd.read_csv(f'{DATASET_ROOT}/sample_submission.csv')
pred_map   = {}

# Zero-shot predictions (dari Section 4)
zs_ids = [f'zs_{i:04d}' for i in range(1, 201)]
for id_, pred in zip(zs_ids, predictions_str):
    pred_map[id_] = pred

# Linear probing predictions (dari Section 5)
lp_ids     = [f'lp_{i:04d}' for i in range(1, 201)]
lp_cls_str = [STL10_CLASSES[p] for p in lp_predictions]
for id_, pred in zip(lp_ids, lp_cls_str):
    pred_map[id_] = pred

# Retrieval predictions (dari Section 6)
for id_, pred in zip(candidates_df['id'].values, predictions_ret.tolist()):
    pred_map[id_] = int(pred)

# MCQA predictions (dari Section 7)
for id_, pred in zip(mcqa_df['id'].values, predictions_mcqa):
    pred_map[id_] = pred
""")

code("""\
# ── Cell 8.2: Generate submission ────────────────────────────────────────────
submission = sample_sub.copy()
submission['prediction'] = submission['id'].map(pred_map)

assert len(submission) == 800,             f"Expected 800 rows, got {len(submission)}"
assert submission['prediction'].isna().sum() == 0, "Ada id yang tidak terprediksi!"

print("Submission preview (2 per task):")
for prefix in ['zs', 'lp', 'ret', 'mcqa']:
    mask = submission['id'].str.startswith(prefix)
    print(submission[mask].head(2).to_string(index=False))
    print()

submission.to_csv('submission.csv', index=False)
print(f"Saved: submission.csv ({len(submission)} rows)")
""")

code("""\
# ── Cell 8.3: Sanity check ────────────────────────────────────────────────────
print("Distribusi prediksi per task:\\n")
for prefix, name in [('zs', 'Zero-shot'), ('lp', 'Linear probe'),
                     ('ret', 'Retrieval'), ('mcqa', 'MCQA')]:
    mask   = submission['id'].str.startswith(prefix)
    subset = submission[mask]
    counts = subset['prediction'].value_counts().to_dict()
    print(f"  {name} ({mask.sum()} items): {counts}")
""")


# ─────────────────────────────────────────────────────────────────────────────
# Write notebook
# ─────────────────────────────────────────────────────────────────────────────

nb.cells = cells

with open('clip_tutorial.ipynb', 'w', encoding='utf-8') as f:
    nbf.write(nb, f)

print("clip_tutorial.ipynb created successfully!")
print(f"Cells: {len(cells)} total")