Delete text_to_image_colab.ipynb

text_to_image_colab.ipynb

@@ -1,351 +0,0 @@
-{
- "nbformat": 4,
- "nbformat_minor": 0,
- "metadata": {
-  "colab": { "provenance": [], "gpuType": "T4" },
-  "kernelspec": { "name": "python3", "display_name": "Python 3" },
-  "language_info": { "name": "python" },
-  "accelerator": "GPU"
- },
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Text-to-Image Generator + Evaluation Metrics\n",
-    "**Dataset:** `rhli/genarena` | **Model:** `runwayml/stable-diffusion-v1-5`\n",
-    "\n",
-    "### Metrics covered\n",
-    "| Metric | Analogue | Range | Better |\n",
-    "|--------|----------|-------|--------|\n",
-    "| CLIP Score | Recall | 0-100 | Higher |\n",
-    "| FID | Precision | 0-inf | Lower |\n",
-    "| Aesthetic Score | Quality | 1-10 | Higher |\n",
-    "\n",
-    "> Enable GPU: **Runtime → Change runtime type → T4 GPU**"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 1. Install dependencies ──────────────────────────────────────────────────\n",
-    "!pip install -q diffusers transformers accelerate datasets pillow huggingface_hub torchvision"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 2. Imports ───────────────────────────────────────────────────────────────\n",
-    "import torch\n",
-    "import numpy as np\n",
-    "import random\n",
-    "import matplotlib.pyplot as plt\n",
-    "from PIL import Image\n",
-    "from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler\n",
-    "from datasets import load_dataset\n",
-    "\n",
-    "DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
-    "DTYPE  = torch.float16 if DEVICE == 'cuda' else torch.float32\n",
-    "print(f'Device: {DEVICE}')\n",
-    "if DEVICE == 'cuda':\n",
-    "    print(f'GPU: {torch.cuda.get_device_name(0)}')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 3. Load generation pipeline ──────────────────────────────────────────────\n",
-    "pipe = StableDiffusionPipeline.from_pretrained(\n",
-    "    'runwayml/stable-diffusion-v1-5',\n",
-    "    torch_dtype=DTYPE,\n",
-    "    safety_checker=None,\n",
-    "    requires_safety_checker=False,\n",
-    ")\n",
-    "pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)\n",
-    "pipe = pipe.to(DEVICE)\n",
-    "if DEVICE == 'cuda':\n",
-    "    pipe.enable_attention_slicing()\n",
-    "print('Generation pipeline ready')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 4. Load dataset ───────────────────────────────────────────────────────────\n",
-    "PROMPT_COLUMN = 'prompt'   # adjust if different after inspecting dataset[0]\n",
-    "dataset = load_dataset('rhli/genarena', split='train')\n",
-    "print(f'Dataset size: {len(dataset)}')\n",
-    "print(f'Columns     : {dataset.column_names}')\n",
-    "print('Sample:', dataset[0])"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 5. Generation helper ─────────────────────────────────────────────────────\n",
-    "def generate(prompt, negative_prompt='blurry, low quality',\n",
-    "             num_steps=20, guidance=7.5, seed=42, show=True):\n",
-    "    generator = torch.Generator(DEVICE).manual_seed(seed)\n",
-    "    ctx = torch.autocast(DEVICE) if DEVICE == 'cuda' else torch.no_grad()\n",
-    "    with ctx:\n",
-    "        result = pipe(\n",
-    "            prompt,\n",
-    "            negative_prompt=negative_prompt,\n",
-    "            num_inference_steps=num_steps,\n",
-    "            guidance_scale=guidance,\n",
-    "            generator=generator,\n",
-    "            height=512, width=512,\n",
-    "        )\n",
-    "    img = result.images[0]\n",
-    "    if show:\n",
-    "        plt.figure(figsize=(5, 5))\n",
-    "        plt.imshow(img)\n",
-    "        plt.axis('off')\n",
-    "        plt.title(prompt[:80], fontsize=9)\n",
-    "        plt.tight_layout()\n",
-    "        plt.show()\n",
-    "    return img\n",
-    "\n",
-    "# Quick test\n",
-    "sample_prompt = dataset[0][PROMPT_COLUMN]\n",
-    "print(f'Generating: {sample_prompt}')\n",
-    "img = generate(sample_prompt)"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "## Evaluation Metrics\n",
-    "\n",
-    "Standard precision/recall require ground-truth labels, which generated images don't have.\n",
-    "The field uses these proxies instead:\n",
-    "\n",
-    "- **CLIP Score** → *Recall* proxy: did the image capture the prompt?\n",
-    "- **FID** → *Precision* proxy: are the images realistic vs. the dataset distribution?\n",
-    "- **Aesthetic Score** → visual quality predictor"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 6. CLIP Score (Recall analogue) ──────────────────────────────────────────\n",
-    "from transformers import CLIPModel, CLIPProcessor\n",
-    "\n",
-    "clip_model     = CLIPModel.from_pretrained('openai/clip-vit-base-patch32').to(DEVICE)\n",
-    "clip_processor = CLIPProcessor.from_pretrained('openai/clip-vit-base-patch32')\n",
-    "\n",
-    "def clip_score(image: Image.Image, prompt: str) -> float:\n",
-    "    \"\"\"\n",
-    "    CLIP Score in [0, 100]. Measures prompt-image alignment.\n",
-    "    Higher is better. Analogue of recall.\n",
-    "    \"\"\"\n",
-    "    inputs = clip_processor(text=[prompt], images=image,\n",
-    "                            return_tensors='pt', padding=True).to(DEVICE)\n",
-    "    with torch.no_grad():\n",
-    "        out     = clip_model(**inputs)\n",
-    "        img_emb = out.image_embeds / out.image_embeds.norm(dim=-1, keepdim=True)\n",
-    "        txt_emb = out.text_embeds  / out.text_embeds.norm(dim=-1, keepdim=True)\n",
-    "        sim     = (img_emb * txt_emb).sum().item()\n",
-    "    return round(float(np.clip(sim * 100, 0, 100)), 2)\n",
-    "\n",
-    "# Example\n",
-    "score = clip_score(img, sample_prompt)\n",
-    "print(f'CLIP Score: {score}/100  ({\"Good\" if score >= 25 else \"Moderate\" if score >= 15 else \"Low\"})')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 7. Aesthetic Score (Visual quality) ───────────────────────────────────────\n",
-    "import torch.nn as nn\n",
-    "from huggingface_hub import hf_hub_download\n",
-    "from transformers import CLIPModel as CLIPModelL, CLIPProcessor as CLIPProcessorL\n",
-    "\n",
-    "class AestheticPredictor(nn.Module):\n",
-    "    def __init__(self, input_size=768):\n",
-    "        super().__init__()\n",
-    "        self.layers = nn.Sequential(\n",
-    "            nn.Linear(input_size, 1024), nn.Dropout(0.2),\n",
-    "            nn.Linear(1024, 128),        nn.Dropout(0.2),\n",
-    "            nn.Linear(128, 64),          nn.Dropout(0.1),\n",
-    "            nn.Linear(64, 16),\n",
-    "            nn.Linear(16, 1),\n",
-    "        )\n",
-    "    def forward(self, x):\n",
-    "        return self.layers(x)\n",
-    "\n",
-    "# Load CLIP ViT-L/14 (larger, used by aesthetic predictor)\n",
-    "print('Loading CLIP ViT-L/14 + aesthetic predictor...')\n",
-    "clip_l     = CLIPModelL.from_pretrained('openai/clip-vit-large-patch14').to(DEVICE)\n",
-    "proc_l     = CLIPProcessorL.from_pretrained('openai/clip-vit-large-patch14')\n",
-    "aes_weights = hf_hub_download('shunk031/aesthetics-predictor',\n",
-    "                               filename='sac+logos+ava1-l14-linearMSE.pth')\n",
-    "aes_model   = AestheticPredictor(768)\n",
-    "aes_model.load_state_dict(torch.load(aes_weights, map_location='cpu'))\n",
-    "aes_model.eval().to(DEVICE)\n",
-    "\n",
-    "def aesthetic_score(image: Image.Image) -> float:\n",
-    "    \"\"\"LAION aesthetic score in [1, 10]. Higher = more visually pleasing.\"\"\"\n",
-    "    inputs = proc_l(images=image, return_tensors='pt').to(DEVICE)\n",
-    "    with torch.no_grad():\n",
-    "        emb   = clip_l.get_image_features(**inputs)\n",
-    "        emb   = emb / emb.norm(dim=-1, keepdim=True)\n",
-    "        score = aes_model(emb).item()\n",
-    "    return round(float(np.clip(score, 1, 10)), 2)\n",
-    "\n",
-    "aes = aesthetic_score(img)\n",
-    "print(f'Aesthetic Score: {aes}/10  ({\"Good\" if aes >= 5 else \"Moderate\" if aes >= 3 else \"Low\"})')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 8. FID — Frechet Inception Distance (Precision analogue) ─────────────────\n",
-    "import torchvision.transforms as T\n",
-    "from torchvision.models import inception_v3\n",
-    "\n",
-    "print('Loading Inception-v3 for FID...')\n",
-    "inception = inception_v3(pretrained=True, transform_input=False)\n",
-    "inception.fc = torch.nn.Identity()   # strip classifier -> 2048-d features\n",
-    "inception.eval().to(DEVICE)\n",
-    "\n",
-    "_tfm = T.Compose([\n",
-    "    T.Resize((299, 299)),\n",
-    "    T.ToTensor(),\n",
-    "    T.Normalize([0.5]*3, [0.5]*3),\n",
-    "])\n",
-    "\n",
-    "def inception_features(images):\n",
-    "    \"\"\"Extract 2048-d Inception-v3 features from a list of PIL images.\"\"\"\n",
-    "    feats = []\n",
-    "    for img in images:\n",
-    "        t = _tfm(img.convert('RGB')).unsqueeze(0).to(DEVICE)\n",
-    "        with torch.no_grad():\n",
-    "            feats.append(inception(t).cpu().numpy())\n",
-    "    return np.concatenate(feats, axis=0)\n",
-    "\n",
-    "def fid_score(gen_images, ref_images):\n",
-    "    \"\"\"\n",
-    "    Frechet Inception Distance. Lower = better.\n",
-    "    Precision analogue: how close is the generated distribution to the real one?\n",
-    "    \"\"\"\n",
-    "    assert len(gen_images) >= 2 and len(ref_images) >= 2, \\\n",
-    "        'Need at least 2 images per group'\n",
-    "\n",
-    "    gen_f = inception_features(gen_images)\n",
-    "    ref_f = inception_features(ref_images)\n",
-    "\n",
-    "    mu_g, sigma_g = gen_f.mean(0), np.cov(gen_f, rowvar=False)\n",
-    "    mu_r, sigma_r = ref_f.mean(0), np.cov(ref_f, rowvar=False)\n",
-    "\n",
-    "    diff = mu_g - mu_r\n",
-    "    eigvals, eigvecs = np.linalg.eigh(sigma_g @ sigma_r)\n",
-    "    eigvals = np.maximum(eigvals, 0)\n",
-    "    sqrt_prod = eigvecs @ np.diag(np.sqrt(eigvals)) @ eigvecs.T\n",
-    "    return round(float(diff @ diff + np.trace(sigma_g + sigma_r - 2 * sqrt_prod)), 2)\n",
-    "\n",
-    "print('FID helpers ready')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 9. Batch evaluation: CLIP + FID ──────────────────────────────────────────\n",
-    "N_GEN = 4    # number of prompts to generate (keep small for speed)\n",
-    "N_REF = 4    # reference images from dataset\n",
-    "\n",
-    "gen_prompts = [dataset[i][PROMPT_COLUMN] for i in random.sample(range(len(dataset)), N_GEN)]\n",
-    "ref_prompts = [dataset[i][PROMPT_COLUMN] for i in random.sample(range(len(dataset)), N_REF)]\n",
-    "\n",
-    "print('Generating images for evaluation...')\n",
-    "gen_images  = [generate(p, show=False) for p in gen_prompts]\n",
-    "ref_images  = [generate(p, show=False) for p in ref_prompts]\n",
-    "\n",
-    "# Per-image CLIP scores\n",
-    "clip_scores = [clip_score(img, p) for img, p in zip(gen_images, gen_prompts)]\n",
-    "\n",
-    "# FID\n",
-    "fid = fid_score(gen_images, ref_images)\n",
-    "\n",
-    "# Report\n",
-    "print('\\n=== Evaluation Results ===')\n",
-    "print(f'Average CLIP Score : {np.mean(clip_scores):.1f}/100  (recall analogue)')\n",
-    "print(f'FID                : {fid:.1f}          (precision analogue; lower=better)')\n",
-    "print()\n",
-    "for i, (p, s) in enumerate(zip(gen_prompts, clip_scores)):\n",
-    "    print(f'  [{i}] CLIP={s:.1f}  \"{p[:60]}\"')\n",
-    "\n",
-    "# Show generated images with scores\n",
-    "fig, axes = plt.subplots(1, N_GEN, figsize=(4*N_GEN, 4))\n",
-    "for ax, img, p, s in zip(axes, gen_images, gen_prompts, clip_scores):\n",
-    "    ax.imshow(img)\n",
-    "    ax.axis('off')\n",
-    "    ax.set_title(f'CLIP={s:.1f}\\n{p[:30]}...', fontsize=7)\n",
-    "plt.suptitle(f'FID={fid:.1f} | Avg CLIP={np.mean(clip_scores):.1f}', fontsize=10)\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 10. Full evaluation on a single custom prompt ────────────────────────────\n",
-    "custom = 'a serene Japanese zen garden at dawn, watercolor style'\n",
-    "\n",
-    "custom_img = generate(custom, seed=999)\n",
-    "\n",
-    "c_score = clip_score(custom_img, custom)\n",
-    "a_score = aesthetic_score(custom_img)\n",
-    "\n",
-    "print(f'Prompt          : {custom}')\n",
-    "print(f'CLIP Score      : {c_score:.1f}/100  (recall – prompt alignment)')\n",
-    "print(f'Aesthetic Score : {a_score:.2f}/10  (visual quality)')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  },
-  {
-   "cell_type": "code",
-   "metadata": {},
-   "source": [
-    "# ── 11. (Optional) Push model to HF Hub ──────────────────────────────────────\n",
-    "# from huggingface_hub import notebook_login\n",
-    "# notebook_login()\n",
-    "# pipe.push_to_hub('YOUR_USERNAME/my-txt2img')\n",
-    "# print('Pushed to Hub')"
-   ],
-   "execution_count": null,
-   "outputs": []
-  }
- ]
-}