Delete build_notebook.py

build_notebook.py

@@ -1,739 +0,0 @@
-"""
-Fills the empty code cells in the Assignment 3 notebook with working code
-for a chest-X-ray recommendation system using CLIP embeddings.
-
-Dataset: MLforHealthcare/mimic-cxr
-   - 30.6k chest X-ray images (train 21.4k / val 4.59k / test 4.6k)
-   - Columns: image (512x512), reports (free-text radiology report)
-
-Model:   openai/clip-vit-base-patch32
-
-NOTE: Standard CLIP wasn't trained on medical images, but it still produces
-useful similarity signals on chest X-rays. For higher-fidelity results you
-can swap MODEL_ID for `flaviagiammarino/pubmed-clip-vit-base-patch32` (a
-biomedical CLIP variant) — the rest of the pipeline is identical.
-"""
-import json
-from pathlib import Path
-
-SRC_PATH = Path("/sessions/focused-inspiring-bohr/mnt/uploads/Copy_of_Assignment_3_Embeddings,_RecSys,_Spaces.ipynb")
-NB_PATH  = Path("/sessions/focused-inspiring-bohr/mnt/outputs/Assignment_3_MIMIC_CXR_Recommender_v3.ipynb")
-
-with SRC_PATH.open() as f:
-    nb = json.load(f)
-
-
-def replace_cell(idx: int, src: str) -> None:
-    """Replace the source of cell `idx` with code `src`."""
-    cell = nb["cells"][idx]
-    assert cell["cell_type"] == "code", f"Cell {idx} is {cell['cell_type']}, not code"
-    lines = src.split("\n")
-    cell["source"] = [l + "\n" for l in lines[:-1]] + ([lines[-1]] if lines[-1] else [])
-    cell["execution_count"] = None
-    cell["outputs"] = []
-
-
-# ============================================================
-# Part 0: Config
-# ============================================================
-
-# Cell 12: imports
-replace_cell(12, '''\
-# Install dependencies (run once in Colab):
-# !pip install -q transformers datasets sentence-transformers umap-learn gradio scikit-learn wordcloud
-
-import os
-import io
-import json
-import base64
-import random
-import re
-from collections import Counter
-
-import numpy as np
-import pandas as pd
-
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-import torch
-from PIL import Image
-
-from datasets import load_dataset
-from transformers import CLIPModel, CLIPProcessor
-
-from sklearn.cluster import KMeans
-from sklearn.decomposition import PCA
-from sklearn.manifold import TSNE
-from sklearn.metrics import silhouette_score
-from sklearn.feature_extraction.text import TfidfVectorizer
-
-try:
-    import umap  # umap-learn
-except ImportError:
-    umap = None''')
-
-# Cell 14: seeds
-replace_cell(14, '''\
-SEED = 42
-
-random.seed(SEED)
-np.random.seed(SEED)
-torch.manual_seed(SEED)
-if torch.cuda.is_available():
-    torch.cuda.manual_seed_all(SEED)
-os.environ["PYTHONHASHSEED"] = str(SEED)''')
-
-# ============================================================
-# Part 1: Select a Visual Dataset
-# ============================================================
-
-# Cell 21: dataset config
-replace_cell(21, '''\
-# Chosen dataset:
-#   MLforHealthcare/mimic-cxr  -  ~30,600 chest X-ray images paired with
-#                                 free-text radiology reports.
-#
-# Why this dataset?
-#   - Visual modality (X-ray images)            -> works with image embeddings
-#   - Mid-size (~30k rows)                      -> fits the 10K-100K bracket
-#   - Each image has a paired radiology report  -> rich semantic information
-#                                                  we can use for clustering
-#                                                  interpretation
-#   - Medical/niche                             -> realistic recommendation
-#                                                  use case: "find prior
-#                                                  studies that look like
-#                                                  this one"
-#
-# DISCLAIMER: This notebook is for educational purposes only. The resulting
-# app is NOT a medical device and must not be used for clinical decisions.
-
-DATASET_ID = "MLforHealthcare/mimic-cxr"
-SPLIT      = "train"
-N_SAMPLES  = 2000   # subsample for fast end-to-end runs on a Colab GPU
-                    # set to None to use the full split''')
-
-# Cell 23: load dataset
-replace_cell(23, '''\
-# Load the dataset from HuggingFace
-raw_ds = load_dataset(DATASET_ID, split=SPLIT)
-print("Full split size:", len(raw_ds))
-print("Features:", raw_ds.features)
-
-# Take a reproducible random subset so the notebook is fast end-to-end
-if N_SAMPLES is not None and N_SAMPLES < len(raw_ds):
-    raw_ds = raw_ds.shuffle(seed=SEED).select(range(N_SAMPLES))
-
-print("Working with:", len(raw_ds), "samples")
-print()
-print("Example row:")
-row = raw_ds[0]
-print("  image:", row["image"].size, row["image"].mode)
-print("  report:", row["reports"][:160] + ("..." if len(row["reports"]) > 160 else ""))''')
-
-# Cell 25: describe
-replace_cell(25, '''\
-# Quick description of the dataset
-
-print(f"Dataset : {DATASET_ID}")
-print(f"Source  : HuggingFace Hub  -  https://huggingface.co/datasets/{DATASET_ID}")
-print(f"Split   : {SPLIT}")
-print(f"Size    : {len(raw_ds):,} images (after subsampling)")
-print(f"Schema  : {list(raw_ds.features.keys())}")
-print()
-print("Per-row contents:")
-print("  - image  : PIL Image, 512x512 grayscale chest X-ray")
-print("  - reports: free-text radiology report describing the findings")
-print()
-print("Key context:")
-print("  - Real (de-identified) chest X-rays.")
-print("  - No discrete class labels - the medical meaning lives in the text reports.")
-print("  - We'll mine that text below to interpret the visual clusters.")''')
-
-# ============================================================
-# Part 2: EDA
-# ============================================================
-
-# Cell 29: build metadata DataFrame
-replace_cell(29, '''\
-# Build a metadata DataFrame for EDA
-records = []
-for i, row in enumerate(raw_ds):
-    img = row["image"]
-    txt = row["reports"] or ""
-    records.append({
-        "idx"          : i,
-        "width"        : img.size[0],
-        "height"       : img.size[1],
-        "mode"         : img.mode,
-        "report"       : txt,
-        "report_len"   : len(txt),
-        "report_words" : len(txt.split()),
-    })
-
-df = pd.DataFrame(records)
-print("Shape:", df.shape)
-df.head()''')
-
-# Cell 30: visual EDA
-replace_cell(30, '''\
-# Sanity checks
-print("Missing values per column:")
-print(df.isna().sum(), "\\n")
-
-print("Image size statistics:")
-print(df[["width", "height"]].describe(), "\\n")
-
-print("Report length statistics (chars / words):")
-print(df[["report_len", "report_words"]].describe(), "\\n")
-
-# --- Plot 1: image dimensions ---
-fig, axes = plt.subplots(1, 2, figsize=(12, 4))
-axes[0].hist(df["width"],  bins=30, color="steelblue", edgecolor="white")
-axes[0].set_title("Image width (px)");  axes[0].set_xlabel("px")
-axes[1].hist(df["height"], bins=30, color="indianred", edgecolor="white")
-axes[1].set_title("Image height (px)"); axes[1].set_xlabel("px")
-plt.tight_layout(); plt.show()
-
-# --- Plot 2: report length distribution ---
-fig, axes = plt.subplots(1, 2, figsize=(12, 4))
-axes[0].hist(df["report_len"],   bins=40, color="seagreen", edgecolor="white")
-axes[0].set_title("Report length (chars)");  axes[0].set_xlabel("characters")
-axes[1].hist(df["report_words"], bins=40, color="darkorange", edgecolor="white")
-axes[1].set_title("Report length (words)");  axes[1].set_xlabel("words")
-plt.tight_layout(); plt.show()
-
-# --- Plot 3: most common medical keywords in the reports ---
-STOP = set("""
-the a an of and or in is are was were be been being has have had this that with
-no not on at to for from by as it its it's there their normal stable unchanged
-unremarkable seen which than have without left right side chest patient study
-view ap pa portable single small large mild moderate severe acute new no new
-since prior compared comparison radiograph radiographs frontal lateral process
-finding findings impression history clinical
-""".split())
-
-def tokenize(t):
-    return [w for w in re.findall(r"[a-zA-Z]+", t.lower()) if w not in STOP and len(w) > 3]
-
-vocab = Counter()
-for t in df["report"]:
-    vocab.update(tokenize(t))
-
-top = vocab.most_common(25)
-print("\\nTop 25 medical terms in the reports:")
-for term, count in top:
-    print(f"  {term:25s} {count}")
-
-plt.figure(figsize=(10, 5))
-terms, counts = zip(*top)
-plt.barh(terms, counts, color="purple")
-plt.gca().invert_yaxis()
-plt.title("Most frequent terms in radiology reports")
-plt.xlabel("count"); plt.tight_layout(); plt.show()
-
-# --- Plot 4: grid of random X-rays ---
-n_show = 12
-sample_idx = np.random.RandomState(SEED).choice(len(raw_ds), n_show, replace=False)
-fig, axes = plt.subplots(2, 6, figsize=(15, 6))
-for ax, i in zip(axes.ravel(), sample_idx):
-    ax.imshow(raw_ds[int(i)]["image"], cmap="gray")
-    ax.set_axis_off()
-plt.suptitle("Random chest X-rays from the working subset")
-plt.tight_layout(); plt.show()''')
-
-# ============================================================
-# Part 3: Embeddings
-# ============================================================
-
-# Cell 34: pick model
-replace_cell(34, '''\
-# Embedding model:
-#   openai/clip-vit-base-patch32  - CLIP ViT-B/32, ~150M params
-#   - Multimodal (image + text), so the Gradio app can accept either input.
-#   - 512-dim L2-normalisable embeddings.
-#   - Robust enough on chest X-rays for cluster-level similarity, even though
-#     it wasn't trained on medical data.
-#
-# Alternative (better for medical images, drop-in compatible):
-#   MODEL_ID = "flaviagiammarino/pubmed-clip-vit-base-patch32"
-
-MODEL_ID  = "openai/clip-vit-base-patch32"
-EMBED_DIM = 512''')
-
-# Cell 36: build the embeddings
-replace_cell(36, '''\
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print("Using device:", device)
-
-clip_model     = CLIPModel.from_pretrained(MODEL_ID).to(device).eval()
-clip_processor = CLIPProcessor.from_pretrained(MODEL_ID)
-
-
-def _to_tensor(out):
-    """Unwrap a CLIP output that may be a tensor or a HuggingFace ModelOutput."""
-    if torch.is_tensor(out):
-        return out
-    if hasattr(out, "image_embeds"):
-        return out.image_embeds
-    if hasattr(out, "text_embeds"):
-        return out.text_embeds
-    if hasattr(out, "pooler_output"):
-        return out.pooler_output
-    if hasattr(out, "last_hidden_state"):
-        return out.last_hidden_state[:, 0]
-    raise TypeError(f"Cannot unwrap CLIP output of type {type(out)}")
-
-
-@torch.no_grad()
-def embed_images(images, batch_size: int = 32) -> np.ndarray:
-    """Compute L2-normalised CLIP image embeddings for a list of PIL images.
-    Uses vision_model + visual_projection explicitly so it works across
-    different transformers versions (some return BaseModelOutputWithPooling
-    from get_image_features instead of a tensor).
-    """
-    feats = []
-    for start in range(0, len(images), batch_size):
-        batch = [img.convert("RGB") for img in images[start:start + batch_size]]
-        inputs = clip_processor(images=batch, return_tensors="pt").to(device)
-        vision_out = clip_model.vision_model(pixel_values=inputs["pixel_values"])
-        pooled = _to_tensor(vision_out)                          # [B, vision_hidden]
-        emb = clip_model.visual_projection(pooled)                # [B, projection_dim]
-        emb = emb / emb.norm(p=2, dim=-1, keepdim=True)           # L2 normalise -> cosine = dot product
-        feats.append(emb.cpu().numpy())
-    return np.concatenate(feats, axis=0)
-
-
-@torch.no_grad()
-def embed_texts(texts) -> np.ndarray:
-    """Compute L2-normalised CLIP text embeddings for a list of strings."""
-    if isinstance(texts, str):
-        texts = [texts]
-    inputs = clip_processor(text=texts, return_tensors="pt",
-                            padding=True, truncation=True, max_length=77).to(device)
-    text_out = clip_model.text_model(
-        input_ids=inputs["input_ids"],
-        attention_mask=inputs.get("attention_mask"),
-    )
-    pooled = _to_tensor(text_out)
-    emb = clip_model.text_projection(pooled)
-    emb = emb / emb.norm(p=2, dim=-1, keepdim=True)
-    return emb.cpu().numpy()
-
-
-# Encode every image in the working subset
-images = [raw_ds[i]["image"] for i in range(len(raw_ds))]
-print(f"Encoding {len(images)} chest X-rays with CLIP...")
-embeddings = embed_images(images, batch_size=64)
-print("Embeddings shape:", embeddings.shape)
-
-df["embedding"] = list(embeddings)
-df.head(3)''')
-
-# ============================================================
-# Part 3.1: 2D projection
-# ============================================================
-
-# Cell 42: PCA
-replace_cell(42, '''\
-# PCA -> 2 components (linear, very fast)
-pca = PCA(n_components=2, random_state=SEED)
-pca_2d = pca.fit_transform(embeddings)
-print(f"PCA explained variance ratio: {pca.explained_variance_ratio_.sum():.3f}")''')
-
-# Cell 43: t-SNE + UMAP + side-by-side plot
-replace_cell(43, '''\
-# t-SNE -> 2D (non-linear)
-tsne = TSNE(n_components=2, random_state=SEED, perplexity=30, init="pca")
-tsne_2d = tsne.fit_transform(embeddings)
-
-# UMAP -> 2D (usually the cleanest separation)
-if umap is not None:
-    umap_model = umap.UMAP(n_components=2, random_state=SEED,
-                           n_neighbors=15, min_dist=0.1)
-    umap_2d = umap_model.fit_transform(embeddings)
-else:
-    umap_2d = None
-
-# Side-by-side plot (colour by report length as a stand-in until we have clusters)
-color = df["report_len"]
-fig, axes = plt.subplots(1, 3, figsize=(18, 5))
-for ax, coords, title in zip(
-    axes,
-    [pca_2d, tsne_2d, umap_2d if umap_2d is not None else pca_2d],
-    ["PCA", "t-SNE", "UMAP" if umap_2d is not None else "PCA (UMAP unavailable)"],
-):
-    sc = ax.scatter(coords[:, 0], coords[:, 1], c=color,
-                    cmap="viridis", s=10, alpha=0.7)
-    ax.set_title(f"{title}  -  CLIP embeddings of X-rays")
-    ax.set_xticks([]); ax.set_yticks([])
-plt.colorbar(sc, ax=axes[-1], label="report length (chars)")
-plt.tight_layout(); plt.show()''')
-
-# ============================================================
-# Part 3.2: clustering
-# ============================================================
-
-# Cell 45: KMeans
-replace_cell(45, '''\
-# Pick k by silhouette score
-ks = list(range(3, 12))
-sil_scores = []
-for k in ks:
-    km = KMeans(n_clusters=k, n_init=10, random_state=SEED).fit(embeddings)
-    sil_scores.append(silhouette_score(
-        embeddings, km.labels_,
-        sample_size=min(1000, len(embeddings)),
-        random_state=SEED,
-    ))
-
-best_k = ks[int(np.argmax(sil_scores))]
-print(f"Best k by silhouette = {best_k}  (score={max(sil_scores):.3f})")
-
-plt.figure(figsize=(7, 3))
-plt.plot(ks, sil_scores, marker="o")
-plt.xlabel("k"); plt.ylabel("silhouette")
-plt.title("Choosing k for KMeans on CLIP embeddings")
-plt.grid(alpha=0.3); plt.show()
-
-kmeans = KMeans(n_clusters=best_k, n_init=10, random_state=SEED).fit(embeddings)
-df["cluster"] = kmeans.labels_''')
-
-# Cell 46: visualise clusters in 2D
-replace_cell(46, '''\
-# Show the chosen 2D projection coloured by cluster
-plt.figure(figsize=(9, 7))
-plt.scatter(tsne_2d[:, 0], tsne_2d[:, 1], c=df["cluster"],
-            cmap="tab10", s=14, alpha=0.85)
-plt.title(f"KMeans clusters (k={best_k}) on CLIP X-ray embeddings  -  t-SNE projection")
-plt.xticks([]); plt.yticks([])
-plt.colorbar(label="cluster")
-plt.show()''')
-
-# ============================================================
-# Part 3.3: cluster interpretation
-# ============================================================
-
-# Cell 48: representative images per cluster
-replace_cell(48, '''\
-# Show the items closest to each cluster centroid - a visual summary
-def closest_to_centroid(cluster_id, k=6):
-    members  = np.where(df["cluster"] == cluster_id)[0]
-    centroid = kmeans.cluster_centers_[cluster_id]
-    dists    = np.linalg.norm(embeddings[members] - centroid, axis=1)
-    return members[np.argsort(dists)[:k]]
-
-fig, axes = plt.subplots(best_k, 6, figsize=(14, 2.4 * best_k))
-if best_k == 1:
-    axes = np.array([axes])
-for c in range(best_k):
-    for j, idx in enumerate(closest_to_centroid(c, 6)):
-        ax = axes[c, j]
-        ax.imshow(raw_ds[int(idx)]["image"], cmap="gray")
-        ax.set_axis_off()
-        if j == 0:
-            ax.set_ylabel(f"cluster {c}",
-                          rotation=0, ha="right", va="center", fontsize=11)
-plt.suptitle("Representative X-rays per cluster (closest to centroid)")
-plt.tight_layout(); plt.show()''')
-
-# Cell 49: TF-IDF over the reports for each cluster -> medical-sense interpretation
-replace_cell(49, '''\
-# Mine the radiology reports inside each cluster to give the clusters a
-# medical interpretation. TF-IDF tells us which terms are distinctive of
-# each cluster relative to the others.
-
-vec = TfidfVectorizer(stop_words="english", max_features=3000,
-                      ngram_range=(1, 2), min_df=5)
-X_tfidf = vec.fit_transform(df["report"].fillna(""))
-terms = np.array(vec.get_feature_names_out())
-
-print("Most distinctive terms per cluster:")
-print("=" * 70)
-for c in range(best_k):
-    mask = df["cluster"].values == c
-    if mask.sum() == 0:
-        continue
-    mean_tfidf = np.asarray(X_tfidf[mask].mean(axis=0)).ravel()
-    top_terms  = terms[np.argsort(-mean_tfidf)[:8]]
-    print(f"cluster {c}  (n={int(mask.sum()):>4d}): {', '.join(top_terms)}")
-print("=" * 70)
-
-# Distribution of cluster sizes
-plt.figure(figsize=(8, 3))
-df["cluster"].value_counts().sort_index().plot(
-    kind="bar", color="teal", edgecolor="white",
-)
-plt.title("Items per cluster"); plt.xlabel("cluster"); plt.ylabel("count")
-plt.tight_layout(); plt.show()
-
-print("""
-Interpretation:
-- Clusters tend to group X-rays by anatomy / equipment / pathology cues that
-  CLIP can pick up visually (lung opacities, presence of catheters and tubes,
-  patient positioning, cardiac silhouette size).
-- The TF-IDF terms above tell us *what kind of finding* each cluster is
-  dominated by - e.g. one cluster may be biased toward "pleural effusion",
-  another toward "cardiomegaly", and a "normal-looking" cluster will be
-  dominated by phrases like "no acute" and "clear".
-""")''')
-
-# ============================================================
-# Part 3.4: save embeddings
-# ============================================================
-
-# Cell 51: persist parquet (used by the Gradio Space)
-replace_cell(51, '''\
-def img_to_b64(pil_img, size=224) -> str:
-    """Encode a PIL image as a base64 JPEG thumbnail so we can ship it in a single parquet."""
-    img = pil_img.convert("L").copy()       # X-rays are grayscale
-    img.thumbnail((size, size))
-    buf = io.BytesIO(); img.save(buf, format="JPEG", quality=85)
-    return base64.b64encode(buf.getvalue()).decode("ascii")
-
-print("Encoding thumbnails...")
-df["image_b64"] = [img_to_b64(raw_ds[i]["image"]) for i in range(len(raw_ds))]
-
-# Store embedding as a python list so it survives the parquet round-trip
-df["embedding"] = df["embedding"].apply(lambda v: np.asarray(v).tolist())
-
-out_path = "embeddings.parquet"
-df.to_parquet(out_path, index=False)
-print(f"Saved {len(df):,} rows to {out_path}  ({os.path.getsize(out_path) / 1e6:.1f} MB)")''')
-
-# Cell 52: sanity-check the parquet
-replace_cell(52, '''\
-# Reload it the way the Gradio Space will
-reload_df = pd.read_parquet(out_path)
-print(reload_df.shape)
-print(reload_df.columns.tolist())
-print("First embedding length:", len(reload_df.loc[0, "embedding"]))
-print("First report preview :", reload_df.loc[0, "report"][:120], "...")''')
-
-# ============================================================
-# Part 4: Inputs & Outputs
-# ============================================================
-
-# Cell 55: in-memory embedding matrix
-replace_cell(55, '''\
-# Build the in-memory matrix the recommender uses
-EMB_MATRIX = np.vstack(df["embedding"].values).astype("float32")
-print("Embedding matrix:", EMB_MATRIX.shape)''')
-
-# Cell 56: pre-decode thumbnails
-replace_cell(56, '''\
-def _b64_to_pil(b64: str) -> Image.Image:
-    img = Image.open(io.BytesIO(base64.b64decode(b64)))
-    img.load()                  # force-load before BytesIO is garbage-collected
-    return img.convert("RGB")    # RGB renders more reliably in Gradio than "L"
-
-THUMBS = [_b64_to_pil(b) for b in df["image_b64"]]''')
-
-# 4.1
-replace_cell(58, '''\
-# 4.1 - Embeddings are persisted to `embeddings.parquet` (see Part 3.4).
-# The Gradio Space loads that single file at startup.
-print("Parquet ready at:", out_path)''')
-
-replace_cell(59, '''\
-# Optional - peek at a single saved row
-pd.read_parquet(out_path).head(1)''')
-
-# 4.2 user input -> embedding
-replace_cell(61, '''\
-def embed_user_input(user_input):
-    """
-    Convert a user input (text or PIL image) into a normalised CLIP embedding.
-    Returns a 1D numpy array of length EMBED_DIM.
-    """
-    if isinstance(user_input, str):
-        return embed_texts([user_input])[0]
-    elif isinstance(user_input, Image.Image):
-        return embed_images([user_input])[0]
-    else:
-        raise TypeError(f"Unsupported input type: {type(user_input)}")''')
-
-replace_cell(62, '''\
-# Quick test - text query
-q = embed_user_input("chest x-ray showing pleural effusion")
-print("query shape:", q.shape, " L2 norm:", np.linalg.norm(q))''')
-
-# 4.3 similarity
-replace_cell(64, '''\
-def similarity_scores(query_vec: np.ndarray) -> np.ndarray:
-    """Cosine similarity between a single query vector and every catalog embedding."""
-    # Embeddings are L2-normalised -> dot product == cosine similarity
-    return EMB_MATRIX @ query_vec.astype("float32")''')
-
-replace_cell(65, '''\
-scores = similarity_scores(q)
-print("min/mean/max:", scores.min(), scores.mean(), scores.max())''')
-
-# 4.4 top-k
-replace_cell(67, '''\
-def top_k(user_input, k: int = 3):
-    """Return the k catalog items most similar to `user_input` (text or PIL image)."""
-    q = embed_user_input(user_input)
-    scores = similarity_scores(q)
-    idx = np.argsort(-scores)[:k]
-    return [
-        {
-            "index"   : int(i),
-            "score"   : float(scores[i]),
-            "image"   : THUMBS[i],
-            "report"  : df.loc[i, "report"],
-            "cluster" : int(df.loc[i, "cluster"]),
-        }
-        for i in idx
-    ]''')
-
-replace_cell(68, '''\
-# Demo: text query
-QUERY = "bilateral pleural effusion with cardiomegaly"
-results = top_k(QUERY, k=3)
-
-fig, axes = plt.subplots(1, 3, figsize=(12, 5))
-for ax, r in zip(axes, results):
-    ax.imshow(r["image"], cmap="gray"); ax.set_axis_off()
-    ax.set_title(f"score={r['score']:.3f}\\ncluster {r['cluster']}", fontsize=10)
-plt.suptitle(f'Top-3 X-rays for: "{QUERY}"')
-plt.tight_layout(); plt.show()
-
-print("Top match report excerpt:")
-print(results[0]["report"][:400] + ("..." if len(results[0]["report"]) > 400 else ""))''')
-
-# ============================================================
-# Part 5: Gradio app
-# ============================================================
-
-replace_cell(71, '''\
-import gradio as gr
-
-def gradio_recommend(text_query, image_query):
-    """
-    Either text or image can be filled in. If both are provided, the image
-    takes precedence (use whichever signal the user actually gave us).
-    Returns (gallery, details_text).
-    """
-    if image_query is not None:
-        query = image_query
-    elif text_query and text_query.strip():
-        query = text_query.strip()
-    else:
-        return [], "Please type a description **or** upload an X-ray."
-
-    results = top_k(query, k=3)
-    gallery = [(r["image"], f"#{r['index']}  -  score {r['score']:.3f}") for r in results]
-    details = "\\n\\n".join(
-        f"### Match {n+1}  (score {r['score']:.3f}, cluster {r['cluster']})\\n"
-        f"{r['report'][:600]}{'...' if len(r['report']) > 600 else ''}"
-        for n, r in enumerate(results)
-    )
-    return gallery, details
-
-
-DESCRIPTION = """
-# Chest X-ray Recommender  -  CLIP embeddings
-
-Upload a chest X-ray **or** describe a finding in words, and the app will
-retrieve the 3 most visually similar X-rays from a 2,000-image catalog
-drawn from `MLforHealthcare/mimic-cxr`.
-
-> Educational demo only. **Not** a medical device. Do not use for clinical decisions.
-"""
-
-demo = gr.Interface(
-    fn=gradio_recommend,
-    inputs=[
-        gr.Textbox(lines=2,
-                   label="Describe a finding (English)",
-                   placeholder='e.g. "bilateral pleural effusion with cardiomegaly"'),
-        gr.Image(type="pil", label="...or upload an X-ray"),
-    ],
-    outputs=[
-        gr.Gallery(label="Top-3 similar X-rays", columns=3, height=350),
-        gr.Markdown(label="Matching radiology reports"),
-    ],
-    title="Chest X-ray Recommender",
-    description=DESCRIPTION,
-    examples=[
-        ["bilateral pleural effusion with cardiomegaly", None],
-        ["clear lungs, no acute cardiopulmonary process", None],
-        ["right lower lobe pneumonia",                    None],
-        ["pneumothorax",                                  None],
-    ],
-)''')
-
-replace_cell(72, '''\
-# Launch (set share=True if you want a public link from Colab)
-demo.launch(share=False, debug=False)''')
-
-# ============================================================
-# Part 5 notes (74)
-# ============================================================
-replace_cell(74, '''\
-# To deploy as a HuggingFace Space:
-#
-# 1. Create a new Space (SDK = Gradio) at https://huggingface.co/new-space
-# 2. Upload these files to the Space repo:
-#       app.py             (Gradio interface, same recommender as above)
-#       requirements.txt   (transformers, torch, datasets, gradio, ...)
-#       embeddings.parquet (built in Part 3.4 of this notebook)
-#       README.md          (Space card + medical disclaimer)
-# 3. The Space will build automatically and host your demo.
-#
-# Files for the Space are bundled next to this notebook (app.py /
-# requirements.txt / README.md). Just upload the four files above.
-print("See app.py, requirements.txt, README.md in the same folder as this notebook.")''')
-
-# ============================================================
-# Part 6 / 7 stubs
-# ============================================================
-replace_cell(77, '''\
-# Replace the YouTube embed URL with the link to your own walk-through video,
-# then add this snippet to app.py so the Space page shows your presentation.
-
-VIDEO_EMBED_HTML = """
-<iframe width="720" height="405"
-        src="https://www.youtube.com/embed/REPLACE_ME"
-        title="Assignment 3 walk-through" frameborder="0"
-        allow="autoplay; encrypted-media; picture-in-picture" allowfullscreen>
-</iframe>
-"""
-print(VIDEO_EMBED_HTML)''')
-
-replace_cell(82, '''\
-# Paste your real Space URL here once it's live
-SPACE_URL = "https://huggingface.co/spaces/<your-username>/chest-xray-recommender"
-print(SPACE_URL)''')
-
-# Cell 90 - HF token
-replace_cell(90, '''\
-# Set HF_TOKEN in Colab via:
-#   from google.colab import userdata
-#   os.environ["HF_TOKEN"] = userdata.get("HF_TOKEN")
-#
-# Or paste it directly (NOT recommended for shared notebooks):
-#   os.environ["HF_TOKEN"] = "hf_..."
-#
-# This assignment doesn't strictly need an HF token to read the dataset
-# (it's public), but you'll need one to push your Space.
-if "HF_TOKEN" in os.environ:
-    print("HF_TOKEN is set.")
-else:
-    print("HF_TOKEN is NOT set. Set it before pushing to a Space.")''')
-
-# ============================================================
-# Save
-# ============================================================
-NB_PATH.write_text(json.dumps(nb, indent=1, ensure_ascii=False))
-print("OK - wrote", NB_PATH, "with", len(nb["cells"]), "cells")
-
-# Validate with nbformat
-try:
-    import nbformat
-    nb_validated = nbformat.read(str(NB_PATH), as_version=4)
-    nbformat.validate(nb_validated)
-    print("Notebook validates against nbformat v4")
-except ImportError:
-    print("nbformat not installed; skipping validation step (notebook JSON is still well-formed)")