{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Which Prompt Made This? \u2014 Baseline\n",
    "\n",
    "**Pelatnas IOAI 2026 \u00b7 Task Diffusion MCQA**\n",
    "\n",
    "Diberikan latent ter-noise `x_t` dari Stable Diffusion v1.4 pada timestep `t` yang\n",
    "diketahui, plus 5 kandidat caption \u2014 pilih caption yang benar.\n",
    "\n",
    "Notebook ini menjalankan **satu** pendekatan sampai selesai dan menghasilkan\n",
    "`submission.csv` yang valid. Pendekatan itu bekerja untuk sebagian soal.\n",
    "Bagian menariknya ada di Section 5.\n",
    "\n",
    "| | |\n",
    "|---|---|\n",
    "| Metrik | Accuracy (chance = 20%) |\n",
    "| Test | 250 soal |\n",
    "| Train | 100 soal berlabel, **dengan kolom `type`** |\n",
    "| Runtime | Colab **T4**, fp16 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip -q install diffusers==0.27.2 transformers accelerate safetensors\n",
    "\n",
    "import torch, numpy as np, pandas as pd\n",
    "print(\"GPU:\", torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"TIDAK ADA GPU\")\n",
    "print(\"torch:\", torch.__version__)\n",
    "assert torch.cuda.is_available(), \"Aktifkan GPU: Runtime > Change runtime type > T4\"\n",
    "\n",
    "DEVICE, DTYPE = \"cuda\", torch.float16"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Muat data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from huggingface_hub import snapshot_download\n",
    "\n",
    "DATA = snapshot_download(repo_id=\"fassabilf/diffusion-mcqa-pelatnas-2026\", repo_type=\"dataset\")\n",
    "print(\"data:\", DATA)\n",
    "\n",
    "train = pd.read_csv(f\"{DATA}/train/train.csv\")\n",
    "test  = pd.read_csv(f\"{DATA}/test/test.csv\")\n",
    "print(train.shape, test.shape)\n",
    "train.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Format latent \u2014 baca ini, hemat 20 menit\n",
    "\n",
    "- File: `train/latents/{id}.npy` dan `test/latents/{id}.npy`\n",
    "- Shape `(4, 64, 64)`, dtype **float16**\n",
    "- **Sudah dikalikan faktor skala VAE `0.18215`** \u2014 siap langsung masuk UNet.\n",
    "  Kamu **tidak** perlu mengalikannya lagi. Untuk VAE decode, bagi dulu dengan\n",
    "  faktor itu.\n",
    "\n",
    "4 channel itu **bukan** RGBA. Tidak ada channel yang berarti \"merah\" atau \"alpha\";\n",
    "itu basis laten hasil belajar VAE dan urutannya arbitrer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_latent(split, i):\n",
    "    return np.load(f\"{DATA}/{split}/latents/{i}.npy\")\n",
    "\n",
    "x = load_latent(\"train\", 0)\n",
    "print(x.shape, x.dtype, f\"mean={x.mean():.3f} std={x.std():.3f}\")\n",
    "print(\"t =\", train.loc[0, \"t\"], \"| jawaban benar:\", train.loc[0, \"label\"])\n",
    "for j in range(5):\n",
    "    print(f\"  [{j}] {train.loc[0, f'choice_{j}']}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Muat Stable Diffusion v1.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from diffusers import AutoencoderKL, UNet2DConditionModel\n",
    "from transformers import CLIPTextModel, CLIPTokenizer, CLIPModel\n",
    "\n",
    "SD  = \"CompVis/stable-diffusion-v1-4\"\n",
    "REV = \"133a221b8aa7292a167afc5127cb63fb5005638b\"          # di-pin supaya semua orang dapat bobot yang sama\n",
    "\n",
    "vae = AutoencoderKL.from_pretrained(SD, subfolder=\"vae\", revision=REV,\n",
    "                                    variant=\"fp16\", torch_dtype=DTYPE).to(DEVICE).eval()\n",
    "unet = UNet2DConditionModel.from_pretrained(SD, subfolder=\"unet\", revision=REV,\n",
    "                                    variant=\"fp16\", torch_dtype=DTYPE).to(DEVICE).eval()\n",
    "# dtype tidak dilewatkan ke transformers: nama argumennya berbeda antara 4.x dan 5.x.\n",
    "# .to(DEVICE, DTYPE) berlaku di keduanya.\n",
    "text_encoder = CLIPTextModel.from_pretrained(SD, subfolder=\"text_encoder\", revision=REV,\n",
    "                                    variant=\"fp16\").to(DEVICE, DTYPE).eval()\n",
    "tokenizer = CLIPTokenizer.from_pretrained(SD, subfolder=\"tokenizer\", revision=REV)\n",
    "\n",
    "clip = CLIPModel.from_pretrained(\"openai/clip-vit-large-patch14\", revision=\"32bd64288804d66eefd0ccbe215aa642df71cc41\").to(DEVICE).eval()\n",
    "clip_tok = CLIPTokenizer.from_pretrained(\"openai/clip-vit-large-patch14\", revision=\"32bd64288804d66eefd0ccbe215aa642df71cc41\")\n",
    "\n",
    "VAE_SCALE = 0.18215\n",
    "print(\"model siap\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Schedule noise\n",
    "\n",
    "Forward process Stable Diffusion:\n",
    "\n",
    "$$x_t = \\sqrt{\\bar\\alpha_t}\\, x_0 + \\sqrt{1-\\bar\\alpha_t}\\, \\varepsilon,\n",
    "\\qquad \\varepsilon \\sim \\mathcal N(0, I)$$\n",
    "\n",
    "`alphas_cumprod[t]` di bawah adalah $\\bar\\alpha_t$. Semakin besar `t`, semakin\n",
    "kecil $\\bar\\alpha_t$, semakin sedikit sisa sinyal gambarnya."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "betas = torch.linspace(0.00085**0.5, 0.012**0.5, 1000, dtype=torch.float64)**2\n",
    "alphas_cumprod = torch.cumprod(1.0 - betas, dim=0)\n",
    "\n",
    "for t in sorted(train[\"t\"].unique()):\n",
    "    a = alphas_cumprod[t].item()\n",
    "    print(f\"t={t:4d}  abar={a:.4f}  sqrt(abar)={a**0.5:.4f}  \"\n",
    "          f\"sqrt(1-abar)={(1-a)**0.5:.4f}  SNR={a/(1-a):.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preview murah: latent2rgb\n",
    "\n",
    "Proyeksi linear `4 -> 3` yang dipakai ComfyUI/A1111 untuk live preview. Kasar,\n",
    "tapi cukup untuk melihat dengan mata apa yang tersisa di tiap level noise \u2014\n",
    "dan jauh lebih cepat daripada VAE decode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "L2RGB = torch.tensor([[ 0.298, 0.207, 0.208],\n",
    "                      [ 0.187, 0.286, 0.173],\n",
    "                      [-0.158, 0.189, 0.264],\n",
    "                      [-0.184,-0.271,-0.473]])\n",
    "\n",
    "def latent2rgb(lat):\n",
    "    x = torch.from_numpy(np.asarray(lat, dtype=np.float32)) / VAE_SCALE\n",
    "    img = torch.einsum(\"chw,cr->hwr\", x, L2RGB)\n",
    "    return ((img - img.min()) / (img.max() - img.min() + 1e-8)).numpy()\n",
    "\n",
    "fig, axes = plt.subplots(1, len(train[\"t\"].unique()), figsize=(4*len(train[\"t\"].unique()), 4))\n",
    "for ax, t in zip(np.atleast_1d(axes), sorted(train[\"t\"].unique())):\n",
    "    i = int(train[train[\"t\"] == t][\"id\"].iloc[0])\n",
    "    ax.imshow(latent2rgb(load_latent(\"train\", i))); ax.set_title(f\"t = {t}\"); ax.axis(\"off\")\n",
    "plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Baseline \u2014 decode lalu cocokkan dengan CLIP\n",
    "\n",
    "Ide paling langsung: `x_t` adalah latent, VAE bisa mengubah latent jadi gambar,\n",
    "CLIP bisa mencocokkan gambar dengan teks. Rangkai ketiganya."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "CLIP_MEAN = torch.tensor([0.48145466, 0.4578275, 0.40821073], device=DEVICE).view(1,3,1,1)\n",
    "CLIP_STD  = torch.tensor([0.26862954, 0.26130258, 0.27577711], device=DEVICE).view(1,3,1,1)\n",
    "\n",
    "def _feat(o):                      # transformers baru mengembalikan objek, bukan tensor\n",
    "    return o if torch.is_tensor(o) else o.pooler_output\n",
    "\n",
    "@torch.no_grad()\n",
    "def decode(latents):\n",
    "    img = vae.decode(latents / VAE_SCALE).sample\n",
    "    return (img / 2 + 0.5).clamp(0, 1)\n",
    "\n",
    "@torch.no_grad()\n",
    "def clip_image(images):\n",
    "    x = torch.nn.functional.interpolate(images.float(), size=224, mode=\"bicubic\",\n",
    "                                        antialias=True, align_corners=False)\n",
    "    f = _feat(clip.get_image_features(pixel_values=(x - CLIP_MEAN) / CLIP_STD))\n",
    "    return torch.nn.functional.normalize(f.float(), dim=-1)\n",
    "\n",
    "@torch.no_grad()\n",
    "def clip_text(captions):\n",
    "    tok = clip_tok(captions, padding=True, truncation=True, max_length=77,\n",
    "                   return_tensors=\"pt\").to(DEVICE)\n",
    "    f = _feat(clip.get_text_features(**tok))\n",
    "    return torch.nn.functional.normalize(f.float(), dim=-1)\n",
    "\n",
    "@torch.no_grad()\n",
    "def baseline_scores(df, split, batch=16):\n",
    "    out = []\n",
    "    for i in range(0, len(df), batch):\n",
    "        grp = df.iloc[i:i+batch]\n",
    "        lat = torch.from_numpy(np.stack([load_latent(split, int(r)) for r in grp[\"id\"]]))\n",
    "        feats = clip_image(decode(lat.to(DEVICE, DTYPE)))\n",
    "        caps  = [r[f\"choice_{j}\"] for _, r in grp.iterrows() for j in range(5)]\n",
    "        txt   = clip_text(caps).view(len(grp), 5, -1)\n",
    "        out.append((feats.unsqueeze(1) * txt).sum(-1).cpu().numpy())\n",
    "    return np.concatenate(out)\n",
    "\n",
    "train_scores = baseline_scores(train, \"train\")\n",
    "train_pred   = train_scores.argmax(1)\n",
    "print(\"akurasi train (keseluruhan):\", f\"{(train_pred == train['label']).mean():.1%}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Evaluasi \u2014 dipecah per tipe soal\n",
    "\n",
    "Satu angka akurasi hampir tidak pernah memberi tahu apa yang harus diperbaiki.\n",
    "`train.csv` punya kolom `type` (test tidak) \u2014 pakai itu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ev = train.copy()\n",
    "ev[\"pred\"]    = train_pred\n",
    "ev[\"correct\"] = (ev[\"pred\"] == ev[\"label\"]).astype(float)\n",
    "\n",
    "tab = ev.groupby(\"type\").agg(t=(\"t\", \"first\"), n=(\"id\", \"size\"), akurasi=(\"correct\", \"mean\"))\n",
    "tab[\"akurasi\"] = tab[\"akurasi\"].map(lambda v: f\"{v:.0%}\")\n",
    "print(tab.to_string())\n",
    "print(f\"\\nchance level = 20%\")\n",
    "\n",
    "ev.groupby(\"type\")[\"correct\"].mean().plot(kind=\"bar\", figsize=(6,3),\n",
    "    title=\"Akurasi baseline per tipe soal (chance = 20%)\")\n",
    "plt.axhline(0.2, color=\"r\", ls=\"--\", label=\"chance\"); plt.legend()\n",
    "plt.ylabel(\"akurasi\"); plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Berhenti sebentar di sini.** Lihat tabelnya, dan lihat kolom `t`-nya.\n",
    "\n",
    "Ada kelompok soal yang diselesaikan baseline ini dengan mudah, dan ada kelompok di\n",
    "mana ia praktis menebak. Sebelum lanjut menulis kode, jawab dulu untuk diri sendiri:\n",
    "*apa tepatnya yang hilang di kelompok yang gagal itu?*\n",
    "\n",
    "Tulis dugaanmu. Nanti dicek waktu debrief."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_scores = baseline_scores(test, \"test\")\n",
    "sub = pd.DataFrame({\"id\": test[\"id\"], \"label\": test_scores.argmax(1)})\n",
    "sub.to_csv(\"submission.csv\", index=False)\n",
    "print(sub.shape)\n",
    "print(sub[\"label\"].value_counts().sort_index().to_dict())\n",
    "sub.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Ke mana selanjutnya\n",
    "\n",
    "Tiga pertanyaan. Tidak ada jawabannya di notebook ini \u2014 itu memang bagian\n",
    "soalnya.\n",
    "\n",
    "---\n",
    "\n",
    "**1.** VAE decode gagal total pada `t` tinggi. Tapi UNet **justru dilatih** pada\n",
    "input persis seperti itu \u2014 latent ter-noise pada level noise sembarang. Kenapa\n",
    "kamu membuang satu-satunya komponen yang memang dirancang untuk membaca input ini?\n",
    "\n",
    "---\n",
    "\n",
    "**2.** `unet(x_t, t, encoder_hidden_states=cond)` mengembalikan sesuatu. Apa\n",
    "tepatnya benda itu, dalam persamaan di Section 3? Dan apa yang berubah pada\n",
    "keluaran itu kalau kamu menukar caption yang dikondisikan \u2014 sementara `x_t` dan\n",
    "`t` dibiarkan sama persis?\n",
    "\n",
    "---\n",
    "\n",
    "**3.** Kamu tidak tahu `\u03b5` yang dipakai untuk membuat `x_t`, dan kami tidak akan\n",
    "memberikannya. Tapi tidak ada yang melarangmu **menambahkan noise-mu sendiri** ke\n",
    "`x_t` untuk naik ke level noise yang lebih tinggi \u2014 dan noise yang itu, kamu tahu\n",
    "persis nilainya.\n",
    "\n",
    "Kalau kamu menempuh jalan ini: pastikan kamu memakai **pasangan noise yang sama\n",
    "untuk kelima caption** pada setiap sampel. Alasannya layak kamu pikirkan sendiri;\n",
    "efeknya pada akurasi jauh lebih besar dari yang kamu duga.\n",
    "\n",
    "---\n",
    "\n",
    "*Anggaran: UNet fp16 di T4 kira-kira 20 forward pass/detik. 250 soal x 5 caption\n",
    "x K sampel. Hitung K yang muat di waktumu sebelum menulis loop-nya.*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.10"
  },
  "accelerator": "GPU",
  "colab": {
   "provenance": [],
   "gpuType": "T4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}