Upload 8 files

.gitattributes

@@ -55,3 +55,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
 Assignment[[:space:]]I.pdf filter=lfs diff=lfs merge=lfs -text
 Assignment-2A-PromptingAsSystemDesign.pdf filter=lfs diff=lfs merge=lfs -text
+demo/Knowledge_Distillation_Report_Group85.pdf filter=lfs diff=lfs merge=lfs -text

demo/Knowledge_Distillation_Report_Group85.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62ad408a156b9cec054031868ef0b849a0759d0bc8f2deb6aa63039fbf39c51f
+size 125251

demo/build_notebook.py

@@ -0,0 +1,971 @@
+"""Builds knowledge_distillation_assignment.ipynb from scratch via nbformat."""
+import nbformat as nbf
+
+nb = nbf.v4.new_notebook()
+cells = []
+
+def md(src):
+    cells.append(nbf.v4.new_markdown_cell(src))
+
+def code(src):
+    cells.append(nbf.v4.new_code_cell(src))
+
+# ---------------------------------------------------------------------------
+# Title
+# ---------------------------------------------------------------------------
+md(r"""# Knowledge Distillation on `PolyAI/banking77`
+
+**Assignment:** Compress a high-capacity fine-tuned Transformer ("Teacher") into a compact, CPU-friendly
+Transformer ("Student") via knowledge distillation, and quantify what is gained and lost in the process.
+
+**Dataset:** [`PolyAI/banking77`](https://huggingface.co/datasets/PolyAI/banking77) — 77-way fine-grained
+banking-intent classification, 10,003 train / 3,080 test utterances.
+
+**Environment:** conda env `agn_env` (Python 3.12), Apple Silicon (MPS acceleration used for teacher
+fine-tuning; the student is trained and benchmarked on **CPU only**, matching its target deployment profile).
+
+| Module | Tasks |
+|---|---|
+| 1. Teacher Labeling & Student Setup | Task 1: Teacher fine-tuning & soft-label generation · Task 2: Student tokenizer alignment |
+| 2. Distillation Architecture & Training | Task 3: Compact student transformer · Task 4: Distillation loss & training |
+| 3. Comparative Analysis & Benchmarking | Task 5: Accuracy vs. compression · Task 6: Deployment metrics |
+""")
+
+# ---------------------------------------------------------------------------
+# Setup
+# ---------------------------------------------------------------------------
+md("## Setup\n\nInstall dependencies directly into the active `agn_env` environment (safe to re-run — a no-op if already satisfied), then import everything used below.")
+
+code(r"""# Ensure required libraries are present in the active (agn_env) kernel.
+import sys
+!{sys.executable} -m pip install -q torch transformers datasets scikit-learn psutil evaluate accelerate tokenizers ipykernel matplotlib
+""")
+
+code(r"""import os
+import gc
+import json
+import time
+import random
+import tempfile
+import subprocess
+from collections import OrderedDict
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader
+import matplotlib.pyplot as plt
+from IPython.display import display, Markdown
+
+from datasets import load_dataset
+from transformers import (
+    AutoTokenizer,
+    BertForSequenceClassification,
+    TrainingArguments,
+    Trainer,
+    DataCollatorWithPadding,
+)
+from tokenizers import Tokenizer as HFTokenizer
+from tokenizers.models import WordPiece
+from tokenizers.trainers import WordPieceTrainer
+from tokenizers.pre_tokenizers import Whitespace
+from tokenizers.normalizers import BertNormalizer
+from tokenizers.processors import TemplateProcessing
+
+from sklearn.metrics import accuracy_score, f1_score
+
+import psutil
+
+SEED = 42
+random.seed(SEED)
+np.random.seed(SEED)
+torch.manual_seed(SEED)
+
+TRAIN_DEVICE = torch.device("mps") if torch.backends.mps.is_available() else torch.device("cpu")
+CPU_DEVICE = torch.device("cpu")
+STUDENT_DEVICE = CPU_DEVICE  # student is trained + benchmarked on CPU throughout: this is the point of the exercise
+
+print(f"Teacher training device : {TRAIN_DEVICE}")
+print(f"Student device (always) : {STUDENT_DEVICE}")
+""")
+
+# ---------------------------------------------------------------------------
+# Module 1 / Task 1
+# ---------------------------------------------------------------------------
+md("""## Module 1: Teacher Labeling & Student Setup
+
+### Task 1 — Teacher Integration & Soft-Label Generation
+
+We fine-tune `bert-base-uncased` (110M parameters) end-to-end on banking77 as our **Teacher**. Once
+fine-tuned, we run one no-grad forward pass over the *entire* training set to cache the Teacher's raw
+77-dimensional **logits** for every example. These cached logits are the "soft labels" used by the
+distillation loss in Task 4 — they are computed once, up front, so the (comparatively expensive) Teacher
+never needs to run again during Student training.""")
+
+code(r"""# Load banking77. The original PolyAI/banking77 repo only ships a loading *script*, which recent
+# versions of `datasets` (>=4.0) no longer execute. We fall back to a verified parquet mirror with
+# identical contents (10,003 train / 3,080 test / same 77 ClassLabel names) if the script path fails.
+try:
+    raw_datasets = load_dataset("PolyAI/banking77")
+    dataset_source = "PolyAI/banking77"
+except Exception as e:
+    print(f"Could not load PolyAI/banking77 directly ({type(e).__name__}); "
+          f"falling back to the parquet mirror legacy-datasets/banking77.")
+    raw_datasets = load_dataset("legacy-datasets/banking77")
+    dataset_source = "legacy-datasets/banking77 (parquet mirror of PolyAI/banking77)"
+
+train_raw = raw_datasets["train"]
+test_raw = raw_datasets["test"]
+label_names = train_raw.features["label"].names
+num_labels = len(label_names)
+
+print(f"Loaded from : {dataset_source}")
+print(f"Train examples : {len(train_raw)}")
+print(f"Test examples  : {len(test_raw)}")
+print(f"Classes        : {num_labels}")
+print(f"\nSample row: {train_raw[0]}")
+print(f"First 10 intents: {label_names[:10]}")
+""")
+
+code(r"""TEACHER_NAME = "bert-base-uncased"
+teacher_tokenizer = AutoTokenizer.from_pretrained(TEACHER_NAME)
+
+def teacher_tokenize(batch):
+    return teacher_tokenizer(batch["text"], truncation=True, max_length=64)
+
+train_enc = train_raw.map(teacher_tokenize, batched=True)
+test_enc = test_raw.map(teacher_tokenize, batched=True)
+
+train_enc = train_enc.rename_column("label", "labels")
+test_enc = test_enc.rename_column("label", "labels")
+train_enc.set_format(type="torch", columns=["input_ids", "attention_mask", "labels"])
+test_enc.set_format(type="torch", columns=["input_ids", "attention_mask", "labels"])
+
+teacher_data_collator = DataCollatorWithPadding(tokenizer=teacher_tokenizer)
+print("Tokenized train/test sets ready for the Teacher.")
+""")
+
+code(r"""teacher_model = BertForSequenceClassification.from_pretrained(TEACHER_NAME, num_labels=num_labels)
+
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    preds = np.argmax(logits, axis=-1)
+    return {
+        "accuracy": accuracy_score(labels, preds),
+        "macro_f1": f1_score(labels, preds, average="macro"),
+    }
+
+teacher_training_args = TrainingArguments(
+    output_dir="./teacher_ckpt",
+    num_train_epochs=3,
+    per_device_train_batch_size=32,
+    per_device_eval_batch_size=64,
+    learning_rate=3e-5,
+    weight_decay=0.01,
+    eval_strategy="epoch",
+    save_strategy="no",
+    logging_steps=50,
+    report_to="none",
+    seed=SEED,
+)
+
+trainer = Trainer(
+    model=teacher_model,
+    args=teacher_training_args,
+    train_dataset=train_enc,
+    eval_dataset=test_enc,
+    data_collator=teacher_data_collator,
+    compute_metrics=compute_metrics,
+)
+
+teacher_train_start = time.time()
+trainer.train()
+teacher_train_seconds = time.time() - teacher_train_start
+print(f"\nTeacher fine-tuning took {teacher_train_seconds/60:.1f} minutes")
+""")
+
+code(r"""teacher_eval_metrics = trainer.evaluate()
+print("Teacher eval metrics (test set):", teacher_eval_metrics)
+""")
+
+code(r"""# Cache soft labels: one no-grad forward pass over the FULL training set, in original (unshuffled)
+# order, so teacher_train_logits[i] corresponds exactly to train_raw[i] by index.
+teacher_model.eval()
+teacher_model.to(TRAIN_DEVICE)
+
+@torch.no_grad()
+def get_teacher_logits(dataset, batch_size=64):
+    loader = DataLoader(dataset, batch_size=batch_size, shuffle=False, collate_fn=teacher_data_collator)
+    all_logits = []
+    for batch in loader:
+        inputs = {k: v.to(TRAIN_DEVICE) for k, v in batch.items() if k != "labels"}
+        outputs = teacher_model(**inputs)
+        all_logits.append(outputs.logits.detach().cpu())
+    return torch.cat(all_logits, dim=0)
+
+teacher_train_logits = get_teacher_logits(train_enc)
+teacher_test_logits = get_teacher_logits(test_enc)
+
+print(f"Cached teacher train logits: {teacher_train_logits.shape}")
+print(f"Cached teacher test logits : {teacher_test_logits.shape}")
+assert teacher_train_logits.shape[0] == len(train_raw)
+""")
+
+md(r"""#### Why soft labels carry "dark knowledge"
+
+A one-hot hard label for the utterance *"I am still waiting on my card?"* says only: **the correct class is
+`card_arrival`, and every other one of the 77 classes is equally, absolutely wrong.** That is not true, and
+it is not what the Teacher actually believes. The Teacher's full softmax distribution over 77 classes might
+look like `card_arrival: 0.62, card_delivery_estimate: 0.21, lost_or_stolen_card: 0.05, ...` — it correctly
+picks `card_arrival`, but it also encodes *how confusable* the other intents are with it.
+
+This matters a great deal on a fine-grained, semantically overlapping taxonomy like banking77, which
+contains many near-duplicate intents (`card_arrival` vs. `card_delivery_estimate`, `declined_card_payment`
+vs. `declined_cash_withdrawal`, `top_up_failed` vs. `pending_top_up`, ...). Training only against a hard
+label throws away exactly the information that describes *why* those pairs are confusable — the relative
+geometry of the Teacher's learned decision boundary. Training against the full distribution instead:
+
+1. **Transfers inter-class similarity structure.** The relative magnitudes of the non-argmax probabilities
+   act as a learned "confusion prior" — pairs of intents the Teacher finds similar get correlated soft
+   targets across many training examples, which is a much richer training signal than 76 identical zeros.
+2. **Provides a smoother, higher-entropy target**, which acts as an implicit regularizer: the Student is not
+   forced to drive its logits to ±∞ to satisfy a one-hot target, so its learned representations generalize
+   better on held-out data, especially with the very limited parameter budget a compact Student has.
+3. **Effectively gives more supervision per example.** A hard label is `log2(77) ≈ 6.3` bits of information at
+   best (which class). A soft label is a full probability vector — many more effective bits — so a Student
+   with less capacity and less data than the Teacher can still recover much of the Teacher's decision
+   surface from the *same* training set.
+4. **Raising the temperature $T$ before softmax** (used in Task 4) further amplifies the small
+   probabilities on non-target classes, which is precisely where most of this structural information lives —
+   at $T{=}1$, those probabilities are so close to zero that gradients from them barely register.
+""")
+
+# ---------------------------------------------------------------------------
+# Task 2
+# ---------------------------------------------------------------------------
+md("""### Task 2 — Student Tokenizer Alignment
+
+The Student will use its **own** compact WordPiece tokenizer (trained from scratch on the banking77 corpus,
+with a vocabulary roughly 10x smaller than BERT's), rather than reusing the Teacher's `bert-base-uncased`
+tokenizer. This section builds that tokenizer and demonstrates how it segments text differently from the
+Teacher's.""")
+
+code(r"""student_tok_backend = HFTokenizer(WordPiece(unk_token="[UNK]"))
+student_tok_backend.normalizer = BertNormalizer(lowercase=True)
+student_tok_backend.pre_tokenizer = Whitespace()
+
+STUDENT_VOCAB_SIZE_TARGET = 3000
+wp_trainer = WordPieceTrainer(
+    vocab_size=STUDENT_VOCAB_SIZE_TARGET,
+    special_tokens=["[PAD]", "[UNK]", "[CLS]", "[SEP]"],
+    min_frequency=1,
+)
+
+corpus_texts = train_raw["text"]
+student_tok_backend.train_from_iterator(corpus_texts, wp_trainer)
+
+student_tok_backend.post_processor = TemplateProcessing(
+    single="[CLS] $A [SEP]",
+    special_tokens=[
+        ("[CLS]", student_tok_backend.token_to_id("[CLS]")),
+        ("[SEP]", student_tok_backend.token_to_id("[SEP]")),
+    ],
+)
+
+STUDENT_VOCAB_SIZE = student_tok_backend.get_vocab_size()
+STUDENT_PAD_ID = student_tok_backend.token_to_id("[PAD]")
+STUDENT_MAX_LEN = 32
+
+print(f"Student vocab size : {STUDENT_VOCAB_SIZE}")
+print(f"Teacher vocab size  : {teacher_tokenizer.vocab_size}")
+print(f"Vocab compression   : {teacher_tokenizer.vocab_size / STUDENT_VOCAB_SIZE:.1f}x smaller")
+""")
+
+code(r"""sample_texts = [train_raw[i]["text"] for i in [0, 1, 2, 3, 4]]
+rows = []
+for t in sample_texts:
+    teacher_toks = teacher_tokenizer.tokenize(t)
+    student_toks = student_tok_backend.encode(t).tokens
+    rows.append({
+        "text": t,
+        "teacher_n_tokens": len(teacher_toks),
+        "teacher_tokens": " ".join(teacher_toks),
+        "student_n_tokens": len(student_toks),
+        "student_tokens": " ".join(student_toks),
+    })
+
+tokenization_comparison = pd.DataFrame(rows)
+tokenization_comparison
+""")
+
+code(r"""def student_encode_batch(texts, max_len=STUDENT_MAX_LEN, pad_id=STUDENT_PAD_ID):
+    encs = student_tok_backend.encode_batch(list(texts))
+    input_ids, attn = [], []
+    for e in encs:
+        ids = e.ids[:max_len]
+        pad_len = max_len - len(ids)
+        attention = [1] * len(ids) + [0] * pad_len
+        ids = ids + [pad_id] * pad_len
+        input_ids.append(ids)
+        attn.append(attention)
+    return torch.tensor(input_ids, dtype=torch.long), torch.tensor(attn, dtype=torch.long)
+
+_demo_ids, _demo_attn = student_encode_batch(sample_texts[:2])
+print("Example padded student input_ids shape:", _demo_ids.shape)
+print(_demo_ids)
+""")
+
+md(r"""#### Handling the vocabulary mismatch between Teacher and Student
+
+A naive version of logit distillation — as used in **token-level** distillation for tasks like
+sequence-to-sequence generation or token classification — requires the Teacher's and Student's output
+sequences to line up position-by-position, which breaks immediately if the two models tokenize the same
+text into different numbers of tokens (which they always will here: the Teacher's ~30k-token vocabulary
+segments text far more coarsely than the Student's ~3k-token vocabulary, as the comparison table above
+shows — the Student consistently needs *more* subword pieces for the same utterance).
+
+**Why this is not actually a hard problem for us:** distillation here is **sequence classification**, not
+sequence generation. The Teacher does not produce a per-token output that would need to line up with the
+Student's per-token output — it produces exactly **one 77-dimensional probability vector per example**,
+regardless of how many tokens that example was split into internally. So the only alignment that matters is
+at the **example (row) level**, not the token level:
+
+- **Strategy used:** compute Teacher logits once per raw-text example (Task 1), indexed by the example's
+  position in the (unshuffled) training set. Independently tokenize the *same* raw text with the Student's
+  own tokenizer for the Student's forward pass. Join the two by index — `teacher_train_logits[i]` always
+  corresponds to `train_raw[i]`, no matter how differently `train_raw[i]["text"]` was tokenized by each
+  side. This is implemented directly in `BankingStudentDataset` below.
+- **Residual risk, and why it's acceptable here:** a much smaller vocabulary means more aggressive subword
+  splitting and a higher `[UNK]` rate, which *can* lose lexical signal the Teacher had access to via its
+  richer vocabulary. We mitigate this by training the Student tokenizer directly on in-domain banking77
+  text (rather than a generic corpus), so the ~3k tokens it does have are the ones that matter most for this
+  task's vocabulary (e.g. "card", "transfer", "pin", "exchange" are highly likely to survive intact as
+  whole-word tokens instead of being fragmented).
+""")
+
+# ---------------------------------------------------------------------------
+# Module 2 / Task 3
+# ---------------------------------------------------------------------------
+md("""## Module 2: Distillation Architecture & Training
+
+### Task 3 — Compact Student Transformer Construction
+
+A small, hand-built encoder-only Transformer: learned token + positional embeddings, 4 Transformer encoder
+layers (hidden size 256, 4 attention heads, feed-forward size 512), mean-pooling over non-padding tokens,
+and a linear classification head to 77 classes. Built directly from `nn.Module` / `nn.TransformerEncoderLayer`
+primitives rather than repurposing a pretrained architecture, and sized to run comfortably on CPU.""")
+
+code(r"""class CompactStudentTransformer(nn.Module):
+    def __init__(self, vocab_size, num_labels, hidden_size=256, num_layers=4, num_heads=4,
+                 ffn_size=512, max_len=32, dropout=0.1, pad_id=0):
+        super().__init__()
+        self.pad_id = pad_id
+        self.token_embedding = nn.Embedding(vocab_size, hidden_size, padding_idx=pad_id)
+        self.position_embedding = nn.Embedding(max_len, hidden_size)
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=hidden_size,
+            nhead=num_heads,
+            dim_feedforward=ffn_size,
+            dropout=dropout,
+            activation="gelu",
+            batch_first=True,
+        )
+        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        self.dropout = nn.Dropout(dropout)
+        self.classifier = nn.Linear(hidden_size, num_labels)
+
+    def forward(self, input_ids, attention_mask):
+        seq_len = input_ids.size(1)
+        positions = torch.arange(seq_len, device=input_ids.device).unsqueeze(0)
+        x = self.token_embedding(input_ids) + self.position_embedding(positions)
+        pad_mask = attention_mask == 0  # True where padded -> ignored by attention
+        x = self.encoder(x, src_key_padding_mask=pad_mask)
+        mask = attention_mask.unsqueeze(-1).float()
+        pooled = (x * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-6)
+        return self.classifier(self.dropout(pooled))
+
+
+# inspect.getsource() cannot recover source for classes defined inside a notebook cell executed by
+# nbconvert (no backing file for linecache to read), so we keep an explicit copy of this class's source
+# alongside it for the subprocess-isolated benchmarking worker script in Task 6.
+STUDENT_CLASS_SOURCE = '''class CompactStudentTransformer(nn.Module):
+    def __init__(self, vocab_size, num_labels, hidden_size=256, num_layers=4, num_heads=4,
+                 ffn_size=512, max_len=32, dropout=0.1, pad_id=0):
+        super().__init__()
+        self.pad_id = pad_id
+        self.token_embedding = nn.Embedding(vocab_size, hidden_size, padding_idx=pad_id)
+        self.position_embedding = nn.Embedding(max_len, hidden_size)
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=hidden_size,
+            nhead=num_heads,
+            dim_feedforward=ffn_size,
+            dropout=dropout,
+            activation="gelu",
+            batch_first=True,
+        )
+        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        self.dropout = nn.Dropout(dropout)
+        self.classifier = nn.Linear(hidden_size, num_labels)
+
+    def forward(self, input_ids, attention_mask):
+        seq_len = input_ids.size(1)
+        positions = torch.arange(seq_len, device=input_ids.device).unsqueeze(0)
+        x = self.token_embedding(input_ids) + self.position_embedding(positions)
+        pad_mask = attention_mask == 0  # True where padded -> ignored by attention
+        x = self.encoder(x, src_key_padding_mask=pad_mask)
+        mask = attention_mask.unsqueeze(-1).float()
+        pooled = (x * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-6)
+        return self.classifier(self.dropout(pooled))
+'''
+
+
+STUDENT_CONFIG = dict(
+    vocab_size=STUDENT_VOCAB_SIZE,
+    num_labels=num_labels,
+    hidden_size=256,
+    num_layers=4,
+    num_heads=4,
+    ffn_size=512,
+    max_len=STUDENT_MAX_LEN,
+    dropout=0.1,
+    pad_id=STUDENT_PAD_ID,
+)
+
+def build_student():
+    torch.manual_seed(SEED)
+    return CompactStudentTransformer(**STUDENT_CONFIG)
+
+_probe = build_student()
+
+def count_params(module):
+    return sum(p.numel() for p in module.parameters())
+
+total_student_params = count_params(_probe)
+embedding_params = count_params(_probe.token_embedding) + count_params(_probe.position_embedding)
+encoder_params = count_params(_probe.encoder)
+classifier_params = count_params(_probe.classifier)
+teacher_params = count_params(teacher_model)
+
+print("Student parameter breakdown")
+print("-" * 40)
+print(f"  Token + position embeddings : {embedding_params:,}")
+print(f"  Transformer encoder (4 layers): {encoder_params:,}")
+print(f"  Classification head          : {classifier_params:,}")
+print(f"  TOTAL                         : {total_student_params:,}")
+print()
+print(f"Teacher (bert-base-uncased) TOTAL: {teacher_params:,}")
+print(f"Compression ratio: {teacher_params / total_student_params:,.1f}x fewer parameters")
+del _probe
+""")
+
+code(r"""display(Markdown(f'''
+#### Interpretation
+
+The compact Student has **{total_student_params:,} parameters** against the Teacher's
+**{teacher_params:,}** — a **{teacher_params/total_student_params:,.1f}x** reduction. Roughly
+**{embedding_params/total_student_params:.0%}** of the Student's budget sits in its embedding table alone,
+which is the direct payoff of Task 2's small, domain-specific vocabulary ({STUDENT_VOCAB_SIZE} tokens vs.
+BERT's {teacher_tokenizer.vocab_size}): most of a Transformer's parameter count for short-sequence
+classification tasks scales with `vocab_size x hidden_size`, so shrinking the vocabulary is one of the single
+highest-leverage compression decisions available, independent of how many encoder layers are kept.
+'''))
+""")
+
+# ---------------------------------------------------------------------------
+# Task 4
+# ---------------------------------------------------------------------------
+md("""### Task 4 — Distillation Loss Function
+
+$$\\text{Loss} = \\alpha \\cdot T^2 \\cdot \\text{KL}\\big(P_{\\text{student}}^T \\,\\|\\, P_{\\text{teacher}}^T\\big) + (1-\\alpha)\\cdot \\text{CE}(y_{\\text{student}}, y_{\\text{true}})$$
+
+with $T = 4.0$ and $\\alpha = 0.7$. The $T^2$ scaling (Hinton et al., 2015) compensates for the fact that
+raising the temperature shrinks the magnitude of the gradients coming from the soft-label term by roughly
+$1/T^2$ relative to the hard-label term, so without it the KD loss would be under-weighted relative to
+$\\alpha$ once a large $T$ is introduced.""")
+
+code(r"""class DistillationLoss(nn.Module):
+    def __init__(self, temperature=4.0, alpha=0.7):
+        super().__init__()
+        self.T = temperature
+        self.alpha = alpha
+        self.kl = nn.KLDivLoss(reduction="batchmean")
+        self.ce = nn.CrossEntropyLoss()
+
+    def forward(self, student_logits, teacher_logits, true_labels):
+        student_log_probs_T = F.log_softmax(student_logits / self.T, dim=-1)
+        teacher_probs_T = F.softmax(teacher_logits / self.T, dim=-1)
+        kd_loss = self.kl(student_log_probs_T, teacher_probs_T) * (self.T ** 2)
+        ce_loss = self.ce(student_logits, true_labels)
+        total = self.alpha * kd_loss + (1 - self.alpha) * ce_loss
+        return total, kd_loss.detach(), ce_loss.detach()
+
+
+class BankingStudentDataset(Dataset):
+    # Joins raw text (re-tokenized with the STUDENT tokenizer) to cached TEACHER logits by row index.
+    def __init__(self, texts, labels, teacher_logits=None):
+        self.input_ids, self.attention_mask = student_encode_batch(texts)
+        self.labels = torch.tensor(labels, dtype=torch.long)
+        self.teacher_logits = teacher_logits
+
+    def __len__(self):
+        return len(self.labels)
+
+    def __getitem__(self, idx):
+        item = {
+            "input_ids": self.input_ids[idx],
+            "attention_mask": self.attention_mask[idx],
+            "labels": self.labels[idx],
+        }
+        if self.teacher_logits is not None:
+            item["teacher_logits"] = self.teacher_logits[idx]
+        return item
+
+
+train_texts, train_labels = train_raw["text"], train_raw["label"]
+test_texts, test_labels = test_raw["text"], test_raw["label"]
+
+distill_train_dataset = BankingStudentDataset(train_texts, train_labels, teacher_logits=teacher_train_logits)
+baseline_train_dataset = BankingStudentDataset(train_texts, train_labels, teacher_logits=None)
+student_test_dataset = BankingStudentDataset(test_texts, test_labels, teacher_logits=None)
+
+print(f"Distillation train set: {len(distill_train_dataset)} examples (with cached teacher logits)")
+print(f"Baseline train set    : {len(baseline_train_dataset)} examples (hard labels only)")
+""")
+
+code(r"""def train_student(model, dataset, device, epochs=8, batch_size=32, lr=3e-4,
+                   distill=False, temperature=4.0, alpha=0.7, log_prefix="student"):
+    model.to(device)
+    loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+    ce_loss_fn = nn.CrossEntropyLoss()
+    distill_loss_fn = DistillationLoss(temperature=temperature, alpha=alpha) if distill else None
+
+    history = {"total": [], "kd": [], "ce": []}
+    model.train()
+    for epoch in range(epochs):
+        totals, kds, ces = [], [], []
+        for batch in loader:
+            input_ids = batch["input_ids"].to(device)
+            attention_mask = batch["attention_mask"].to(device)
+            labels = batch["labels"].to(device)
+
+            optimizer.zero_grad()
+            logits = model(input_ids, attention_mask)
+
+            if distill:
+                teacher_logits = batch["teacher_logits"].to(device)
+                loss, kd, ce = distill_loss_fn(logits, teacher_logits, labels)
+                kds.append(kd.item())
+                ces.append(ce.item())
+            else:
+                loss = ce_loss_fn(logits, labels)
+
+            loss.backward()
+            optimizer.step()
+            totals.append(loss.item())
+
+        avg_total = float(np.mean(totals))
+        history["total"].append(avg_total)
+        if distill:
+            history["kd"].append(float(np.mean(kds)))
+            history["ce"].append(float(np.mean(ces)))
+            print(f"[{log_prefix}] epoch {epoch+1}/{epochs} - loss {avg_total:.4f} "
+                  f"(kd {history['kd'][-1]:.4f}, ce {history['ce'][-1]:.4f})")
+        else:
+            print(f"[{log_prefix}] epoch {epoch+1}/{epochs} - loss {avg_total:.4f}")
+    return history
+
+STUDENT_EPOCHS = 8
+""")
+
+code(r"""torch.manual_seed(SEED)
+distilled_student = build_student()
+
+distill_start = time.time()
+distill_history = train_student(
+    distilled_student, distill_train_dataset, STUDENT_DEVICE,
+    epochs=STUDENT_EPOCHS, batch_size=32, lr=3e-4,
+    distill=True, temperature=4.0, alpha=0.7, log_prefix="distilled",
+)
+distill_seconds = time.time() - distill_start
+print(f"\nDistilled student training took {distill_seconds:.1f}s on {STUDENT_DEVICE}")
+""")
+
+code(r"""fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+axes[0].plot(distill_history["total"], marker="o", label="total loss")
+axes[0].set_title("Distilled student: total loss")
+axes[0].set_xlabel("epoch"); axes[0].set_ylabel("loss"); axes[0].legend()
+
+axes[1].plot(distill_history["kd"], marker="o", label="KD term (KL, T-scaled)")
+axes[1].plot(distill_history["ce"], marker="s", label="CE term (hard labels)")
+axes[1].set_title("Distilled student: loss components")
+axes[1].set_xlabel("epoch"); axes[1].set_ylabel("loss"); axes[1].legend()
+plt.tight_layout()
+plt.show()
+""")
+
+md("""**Interpretation:** the CE component (against ground-truth hard labels) typically drops faster and
+further than the KD component, because a 3000-token-vocabulary, 4-layer Student can quickly memorize the
+*correct class* for a small, well-separated training set, while matching the Teacher's *full smoothed
+distribution* over 77 classes at $T{=}4$ is a strictly harder target — the KD term keeps providing a
+non-trivial gradient signal well after the CE term has largely converged, which is exactly the regime where
+distillation is doing useful work beyond what hard labels alone would teach.""")
+
+# ---------------------------------------------------------------------------
+# Module 3 / Task 5
+# ---------------------------------------------------------------------------
+md("""## Module 3: Comparative Analysis & Benchmarking
+
+### Task 5 — Accuracy vs. Compression Evaluation
+
+We now train an **identical-architecture baseline Student** from scratch using plain cross-entropy on
+ground-truth labels only (no Teacher signal at all), so any accuracy difference between it and the
+distilled Student isolates the effect of distillation itself, holding architecture, tokenizer, optimizer,
+and epoch budget fixed.""")
+
+code(r"""torch.manual_seed(SEED)
+baseline_student = build_student()
+
+baseline_start = time.time()
+baseline_history = train_student(
+    baseline_student, baseline_train_dataset, STUDENT_DEVICE,
+    epochs=STUDENT_EPOCHS, batch_size=32, lr=3e-4,
+    distill=False, log_prefix="baseline",
+)
+baseline_seconds = time.time() - baseline_start
+print(f"\nBaseline student training took {baseline_seconds:.1f}s on {STUDENT_DEVICE}")
+""")
+
+code(r"""plt.figure(figsize=(6, 4))
+plt.plot(baseline_history["total"], marker="o", label="Baseline student (CE only)")
+plt.plot(distill_history["total"], marker="s", label="Distilled student (KD + CE)")
+plt.title("Training loss: baseline vs. distilled student")
+plt.xlabel("epoch"); plt.ylabel("loss (not directly comparable in scale)"); plt.legend()
+plt.tight_layout()
+plt.show()
+""")
+
+code(r"""@torch.no_grad()
+def evaluate_student(model, dataset, device, batch_size=64):
+    model.eval()
+    model.to(device)
+    loader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
+    all_preds, all_labels = [], []
+    for batch in loader:
+        input_ids = batch["input_ids"].to(device)
+        attention_mask = batch["attention_mask"].to(device)
+        logits = model(input_ids, attention_mask)
+        all_preds.extend(torch.argmax(logits, dim=-1).cpu().numpy().tolist())
+        all_labels.extend(batch["labels"].numpy().tolist())
+    return np.array(all_preds), np.array(all_labels)
+
+
+teacher_pred_output = trainer.predict(test_enc)
+teacher_test_preds = np.argmax(teacher_pred_output.predictions, axis=-1)
+teacher_test_labels = np.array(test_raw["label"])
+
+baseline_preds, baseline_labels = evaluate_student(baseline_student, student_test_dataset, STUDENT_DEVICE)
+distilled_preds, distilled_labels = evaluate_student(distilled_student, student_test_dataset, STUDENT_DEVICE)
+
+def summarize(name, preds, labels):
+    return {
+        "Model": name,
+        "Accuracy": accuracy_score(labels, preds),
+        "Macro F1": f1_score(labels, preds, average="macro"),
+        "Weighted F1": f1_score(labels, preds, average="weighted"),
+    }
+
+results_df = pd.DataFrame([
+    summarize("Teacher (bert-base-uncased)", teacher_test_preds, teacher_test_labels),
+    summarize("Student — WITHOUT distillation", baseline_preds, baseline_labels),
+    summarize("Student — WITH distillation", distilled_preds, distilled_labels),
+])
+results_df[["Accuracy", "Macro F1", "Weighted F1"]] = results_df[["Accuracy", "Macro F1", "Weighted F1"]].round(4)
+results_df
+""")
+
+code(r"""def to_markdown_table(df):
+    header = "| " + " | ".join(df.columns) + " |"
+    sep = "|" + "|".join(["---"] * len(df.columns)) + "|"
+    rows = ["| " + " | ".join(str(v) for v in row) + " |" for row in df.values]
+    return "\n".join([header, sep] + rows)
+
+teacher_acc = results_df.loc[0, "Accuracy"]
+baseline_acc = results_df.loc[1, "Accuracy"]
+distilled_acc = results_df.loc[2, "Accuracy"]
+recovery = (distilled_acc - baseline_acc) / max(teacher_acc - baseline_acc, 1e-9) * 100
+retention = distilled_acc / teacher_acc * 100
+
+if distilled_acc >= teacher_acc:
+    gap_line = (
+        f"- Adding the Teacher's soft labels (identical architecture, identical data, identical epoch budget — "
+        f"only the loss function differs) raises the Student to **{distilled_acc:.1%}** accuracy, which "
+        f"**fully closes** the gap to the Teacher's **{teacher_acc:.1%}** and slightly surpasses it."
+    )
+    retention_line = (
+        f"- Remarkably, the distilled Student's **{distilled_acc:.1%}** accuracy matches — and here, "
+        f"slightly exceeds — the Teacher's **{teacher_acc:.1%}**, at **{teacher_params/total_student_params:,.0f}x** "
+        f"fewer parameters. This is a stronger-than-typical (though not unheard of) outcome: the Teacher was "
+        f"only fine-tuned for a few epochs, so its own decision boundary still carries some noise, and the "
+        f"test set is a few thousand examples, so a couple of points either way is within normal variance. "
+        f"The soft-label targets act as a strong regularizer that helps the tiny Student generalize at least "
+        f"as well on this held-out set — that does **not** mean the Student has absorbed *all* of the "
+        f"Teacher's knowledge, only that on this test split and this metric, distillation fully closed the gap."
+    )
+else:
+    gap_line = (
+        f"- Adding the Teacher's soft labels (identical architecture, identical data, identical epoch budget — "
+        f"only the loss function differs) raises the Student to **{distilled_acc:.1%}** accuracy, closing "
+        f"**{recovery:.0f}%** of the accuracy gap between the undistilled Student and the Teacher."
+    )
+    retention_line = (
+        f"- The distilled Student retains **{retention:.1f}%** of the Teacher's accuracy at a fraction of its "
+        f"parameter count — this is the central empirical claim of knowledge distillation: dark knowledge in "
+        f"the soft labels lets a small model recover much more of a large model's decision surface than the "
+        f"same small model could learn from hard labels alone."
+    )
+
+display(Markdown(f'''
+#### Comparison table
+
+{to_markdown_table(results_df)}
+
+#### Interpretation
+
+- The undistilled Student, trained only on hard labels with a **{teacher_params/total_student_params:,.0f}x**
+  smaller architecture and a **{STUDENT_EPOCHS}**-epoch budget over the same {len(train_raw)} examples,
+  reaches **{baseline_acc:.1%}** accuracy — a substantial gap below the Teacher's **{teacher_acc:.1%}**,
+  as expected given how much capacity was removed.
+{gap_line}
+{retention_line}
+'''))
+""")
+
+# ---------------------------------------------------------------------------
+# Task 6
+# ---------------------------------------------------------------------------
+md("""### Task 6 — Deployment Metrics Analysis
+
+We measure three deployment-relevant metrics for the Teacher vs. the (distilled) Student:
+
+1. **Disk size** — serialized `state_dict` size on disk.
+2. **CPU inference latency** — mean wall-clock time per single-example (`batch_size=1`) forward pass on CPU.
+3. **Peak process RAM** — measured in an **isolated subprocess per model** (via `resource.getrusage`), so
+   the Teacher's ~440MB footprint doesn't contaminate the Student's measurement just because both happen to
+   be loaded in the same notebook kernel.""")
+
+code(r"""def get_model_disk_size_mb(state_dict):
+    with tempfile.NamedTemporaryFile(suffix=".pt") as f:
+        torch.save(state_dict, f.name)
+        f.flush()
+        size_bytes = os.path.getsize(f.name)
+    return size_bytes / (1024 ** 2)
+
+teacher_size_mb = get_model_disk_size_mb(teacher_model.state_dict())
+student_size_mb = get_model_disk_size_mb(distilled_student.state_dict())
+
+print(f"Teacher disk size : {teacher_size_mb:,.1f} MB")
+print(f"Student disk size : {student_size_mb:,.1f} MB")
+print(f"Size reduction    : {teacher_size_mb/student_size_mb:,.1f}x smaller")
+""")
+
+code(r"""@torch.no_grad()
+def measure_teacher_cpu_latency(model, tokenizer, texts, n_warmup=5, n_runs=50):
+    model.to(CPU_DEVICE)
+    model.eval()
+    encs = [tokenizer(t, return_tensors="pt", truncation=True, max_length=64) for t in texts]
+    for i in range(n_warmup):
+        model(**encs[i % len(encs)])
+    times = []
+    for i in range(n_runs):
+        enc = encs[i % len(encs)]
+        start = time.perf_counter()
+        model(**enc)
+        times.append((time.perf_counter() - start) * 1000)
+    return float(np.mean(times)), float(np.std(times))
+
+@torch.no_grad()
+def measure_student_cpu_latency(model, texts, n_warmup=5, n_runs=50):
+    model.to(CPU_DEVICE)
+    model.eval()
+    ids, attn = student_encode_batch(texts)
+    for i in range(n_warmup):
+        idx = i % len(texts)
+        model(ids[idx].unsqueeze(0), attn[idx].unsqueeze(0))
+    times = []
+    for i in range(n_runs):
+        idx = i % len(texts)
+        start = time.perf_counter()
+        model(ids[idx].unsqueeze(0), attn[idx].unsqueeze(0))
+        times.append((time.perf_counter() - start) * 1000)
+    return float(np.mean(times)), float(np.std(times))
+
+latency_sample_texts = test_texts[:20]
+teacher_latency_mean, teacher_latency_std = measure_teacher_cpu_latency(teacher_model, teacher_tokenizer, latency_sample_texts)
+student_latency_mean, student_latency_std = measure_student_cpu_latency(distilled_student, latency_sample_texts)
+
+print(f"Teacher CPU latency : {teacher_latency_mean:.2f} +/- {teacher_latency_std:.2f} ms/query")
+print(f"Student CPU latency : {student_latency_mean:.2f} +/- {student_latency_std:.2f} ms/query")
+print(f"Speedup             : {teacher_latency_mean/student_latency_mean:,.1f}x faster")
+""")
+
+code(r"""# Peak RAM, measured per model in an isolated subprocess so each number reflects ONLY that model's
+# footprint (loading both Teacher and Student into one long-lived kernel would make ru_maxrss monotonically
+# dominated by whichever model was loaded first).
+teacher_worker_src = (
+    "import sys, resource, torch\n"
+    "from transformers import BertForSequenceClassification, AutoTokenizer\n"
+    "model_dir = sys.argv[1]\n"
+    "model = BertForSequenceClassification.from_pretrained(model_dir)\n"
+    "tokenizer = AutoTokenizer.from_pretrained(model_dir)\n"
+    "model.eval()\n"
+    "texts = ['I am still waiting on my card?'] * 30\n"
+    "with torch.no_grad():\n"
+    "    for t in texts:\n"
+    "        enc = tokenizer(t, return_tensors='pt', truncation=True, max_length=64)\n"
+    "        model(**enc)\n"
+    "print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)\n"
+)
+
+student_class_src = STUDENT_CLASS_SOURCE
+student_worker_src = (
+    "import sys, json, resource, torch\n"
+    "import torch.nn as nn\n"
+    "from tokenizers import Tokenizer as HFTokenizer\n\n"
+    + student_class_src + "\n\n"
+    "model_dir = sys.argv[1]\n"
+    "cfg = json.load(open(model_dir + '/config.json'))\n"
+    "model = CompactStudentTransformer(**cfg)\n"
+    "model.load_state_dict(torch.load(model_dir + '/weights.pt', map_location='cpu'))\n"
+    "model.eval()\n"
+    "tok = HFTokenizer.from_file(model_dir + '/tokenizer.json')\n"
+    "texts = ['I am still waiting on my card?'] * 30\n"
+    "with torch.no_grad():\n"
+    "    for t in texts:\n"
+    "        ids = tok.encode(t).ids[:cfg['max_len']]\n"
+    "        pad_len = cfg['max_len'] - len(ids)\n"
+    "        attn = [1]*len(ids) + [0]*pad_len\n"
+    "        ids = ids + [cfg['pad_id']]*pad_len\n"
+    "        input_ids = torch.tensor([ids])\n"
+    "        attention_mask = torch.tensor([attn])\n"
+    "        model(input_ids, attention_mask)\n"
+    "print(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)\n"
+)
+
+with tempfile.TemporaryDirectory() as tmp_root:
+    teacher_dir = os.path.join(tmp_root, "teacher")
+    student_dir = os.path.join(tmp_root, "student")
+    os.makedirs(teacher_dir, exist_ok=True)
+    os.makedirs(student_dir, exist_ok=True)
+
+    teacher_model.save_pretrained(teacher_dir)
+    teacher_tokenizer.save_pretrained(teacher_dir)
+
+    torch.save(distilled_student.state_dict(), os.path.join(student_dir, "weights.pt"))
+    with open(os.path.join(student_dir, "config.json"), "w") as f:
+        json.dump(STUDENT_CONFIG, f)
+    student_tok_backend.save(os.path.join(student_dir, "tokenizer.json"))
+
+    teacher_worker_path = os.path.join(tmp_root, "teacher_worker.py")
+    student_worker_path = os.path.join(tmp_root, "student_worker.py")
+    with open(teacher_worker_path, "w") as f:
+        f.write(teacher_worker_src)
+    with open(student_worker_path, "w") as f:
+        f.write(student_worker_src)
+
+    teacher_ram_out = subprocess.run(
+        [sys.executable, teacher_worker_path, teacher_dir],
+        capture_output=True, text=True, check=True,
+    )
+    student_ram_out = subprocess.run(
+        [sys.executable, student_worker_path, student_dir],
+        capture_output=True, text=True, check=True,
+    )
+
+_bytes_per_unit = 1  # macOS ru_maxrss is already in bytes
+teacher_peak_ram_mb = int(teacher_ram_out.stdout.strip()) * _bytes_per_unit / (1024 ** 2)
+student_peak_ram_mb = int(student_ram_out.stdout.strip()) * _bytes_per_unit / (1024 ** 2)
+
+print(f"Teacher peak RAM (isolated process) : {teacher_peak_ram_mb:,.1f} MB")
+print(f"Student peak RAM (isolated process) : {student_peak_ram_mb:,.1f} MB")
+print(f"RAM reduction                        : {teacher_peak_ram_mb/student_peak_ram_mb:,.1f}x smaller")
+""")
+
+code(r"""deployment_df = pd.DataFrame([
+    {"Metric": "Disk size (MB)", "Teacher": round(teacher_size_mb, 1), "Student": round(student_size_mb, 1),
+     "Reduction": f"{teacher_size_mb/student_size_mb:.1f}x"},
+    {"Metric": "CPU latency (ms/query)", "Teacher": round(teacher_latency_mean, 2), "Student": round(student_latency_mean, 2),
+     "Reduction": f"{teacher_latency_mean/student_latency_mean:.1f}x"},
+    {"Metric": "Peak RAM (MB)", "Teacher": round(teacher_peak_ram_mb, 1), "Student": round(student_peak_ram_mb, 1),
+     "Reduction": f"{teacher_peak_ram_mb/student_peak_ram_mb:.1f}x"},
+])
+deployment_df
+""")
+
+code(r"""accuracy_retained_pct = distilled_acc / teacher_acc * 100
+size_reduction_x = teacher_size_mb / student_size_mb
+latency_reduction_x = teacher_latency_mean / student_latency_mean
+ram_reduction_x = teacher_peak_ram_mb / student_peak_ram_mb
+
+if distilled_acc >= teacher_acc:
+    accuracy_summary_line = (
+        f"while matching (here, slightly exceeding) its accuracy on the exact same 77-way classification task."
+    )
+    accuracy_tradeoff_bullet = (
+        f"- **Accuracy trade-off** — in this run there isn't one: the distilled Student's accuracy is at "
+        f"least as high as the Teacher's, so the size/latency/RAM wins below come essentially for free on "
+        f"this test set. That is a favorable outcome, not a guarantee — it reflects a lightly-fine-tuned "
+        f"Teacher and a modest-size test set as much as it reflects the Student's quality, so a production "
+        f"rollout should still monitor accuracy on live traffic rather than assuming this margin holds "
+        f"indefinitely as data drifts."
+    )
+else:
+    accuracy_summary_line = (
+        f"while retaining **{accuracy_retained_pct:.1f}%** of its accuracy on the exact same 77-way "
+        f"classification task."
+    )
+    accuracy_tradeoff_bullet = (
+        f"- **Accuracy trade-off** — the real cost is the **{100-accuracy_retained_pct:.1f} percentage "
+        f"points** of relative accuracy given up. Whether that is acceptable depends entirely on the "
+        f"product: for a first-pass intent router that falls back to a human agent or a larger cloud model "
+        f"on low confidence, this trade is usually a clear win — the compute/latency/cost savings at massive "
+        f"query volume outweigh a modest accuracy gap. For a fully autonomous decision with no fallback "
+        f"(e.g. auto-approving a refund), the remaining gap to the Teacher may still be too large to deploy "
+        f"the Student *alone*."
+    )
+
+display(Markdown(f'''
+#### Deployment-readiness analysis
+
+{to_markdown_table(deployment_df)}
+
+The distilled Student is **{size_reduction_x:.1f}x smaller on disk**, **{latency_reduction_x:.1f}x faster**
+per CPU query, and uses **{ram_reduction_x:.1f}x less peak RAM** than the Teacher, {accuracy_summary_line}
+
+**Is this deployment-ready for edge/mobile?**
+
+- **Size and RAM** — at ~{student_size_mb:.0f}MB on disk and ~{student_peak_ram_mb:.0f}MB of peak RAM, the
+  Student comfortably fits within the memory budgets of edge devices and mobile apps, where a
+  {teacher_size_mb:.0f}MB+ BERT-base checkpoint is frequently a non-starter (app-store bundle-size limits,
+  low-RAM Android devices, on-device model caches).
+- **Latency** — {student_latency_mean:.1f}ms/query on CPU is well within the range needed for a responsive,
+  synchronous UI interaction (e.g. intent routing as a user types), whereas the Teacher's
+  {teacher_latency_mean:.1f}ms/query, multiplied across a request queue on a resource-constrained device,
+  would noticeably degrade perceived responsiveness.
+{accuracy_tradeoff_bullet}
+- **Practical recommendation** — deploy the distilled Student as the default path, and route low-confidence
+  predictions (small margin between the top-2 softmax probabilities) to the Teacher or a human reviewer.
+  This captures most of the size/latency/RAM benefits demonstrated above while bounding the accuracy risk
+  to only the genuinely ambiguous cases — which is exactly the scenario dark-knowledge distillation is
+  suited for, since the Student was trained to mimic the Teacher's *confidence structure*, not just its
+  argmax.
+'''))
+""")
+
+nb["cells"] = cells
+with open("knowledge_distillation_assignment.ipynb", "w") as f:
+    nbf.write(nb, f)
+
+print(f"Notebook written with {len(cells)} cells.")

demo/build_pdf_report.py

@@ -0,0 +1,585 @@
+"""Builds Knowledge_Distillation_Report_Group85.pdf via ReportLab (weasyprint unavailable: missing
+native Pango/GObject libs on this system). Produces a cover page, bookmarked TOC, styled section
+headings, tables, formula callouts, and the two loss-curve figures extracted from the executed notebook.
+"""
+import os
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import cm, inch
+from reportlab.lib import colors
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_JUSTIFY
+from reportlab.platypus import (
+    BaseDocTemplate, PageTemplate, Frame, Paragraph, Spacer, Table, TableStyle,
+    Image, PageBreak, NextPageTemplate, FrameBreak, KeepTogether, ListFlowable, ListItem,
+)
+from reportlab.platypus.tableofcontents import TableOfContents
+from reportlab.pdfgen import canvas as canvas_mod
+from PIL import Image as PILImage
+
+ASSETS = "/Users/reevechaitanya/Documents/2_Experimentation_n_Research/demo/report_assets"
+OUT_PATH = "/Users/reevechaitanya/Documents/2_Experimentation_n_Research/demo/Knowledge_Distillation_Report_Group85.pdf"
+
+PAGE_W, PAGE_H = A4
+MARGIN = 2.0 * cm
+CONTENT_W = PAGE_W - 2 * MARGIN
+
+ACCENT = colors.HexColor("#1F4E79")
+ACCENT_LIGHT = colors.HexColor("#DCE6F1")
+GREY = colors.HexColor("#404040")
+LIGHT_GREY = colors.HexColor("#F2F2F2")
+BORDER_GREY = colors.HexColor("#9AA7B0")
+GOOD_GREEN = colors.HexColor("#2E7D32")
+
+# ---------------------------------------------------------------------------
+# Styles
+# ---------------------------------------------------------------------------
+base = getSampleStyleSheet()
+
+styles = {}
+styles["CoverTitle"] = ParagraphStyle("CoverTitle", parent=base["Title"], fontName="Helvetica-Bold",
+                                       fontSize=25, leading=30, textColor=ACCENT, alignment=TA_CENTER,
+                                       spaceAfter=6)
+styles["CoverSub"] = ParagraphStyle("CoverSub", parent=base["Normal"], fontName="Helvetica",
+                                     fontSize=13, leading=18, textColor=GREY, alignment=TA_CENTER,
+                                     spaceAfter=4)
+styles["CoverMeta"] = ParagraphStyle("CoverMeta", parent=base["Normal"], fontName="Helvetica",
+                                      fontSize=11, leading=16, textColor=GREY, alignment=TA_CENTER)
+styles["CoverLabel"] = ParagraphStyle("CoverLabel", parent=base["Normal"], fontName="Helvetica-Bold",
+                                       fontSize=11, leading=15, textColor=ACCENT, alignment=TA_LEFT)
+styles["CoverValue"] = ParagraphStyle("CoverValue", parent=base["Normal"], fontName="Helvetica",
+                                       fontSize=11, leading=15, textColor=GREY, alignment=TA_LEFT)
+
+styles["H1"] = ParagraphStyle("H1", parent=base["Heading1"], fontName="Helvetica-Bold", fontSize=17,
+                               leading=21, textColor=colors.white, spaceBefore=0, spaceAfter=0,
+                               backColor=ACCENT, borderPadding=(6, 8, 6, 8), alignment=TA_LEFT)
+styles["H2"] = ParagraphStyle("H2", parent=base["Heading2"], fontName="Helvetica-Bold", fontSize=13.5,
+                               leading=17, textColor=ACCENT, spaceBefore=14, spaceAfter=6,
+                               borderColor=ACCENT, borderWidth=0, alignment=TA_LEFT)
+styles["H3"] = ParagraphStyle("H3", parent=base["Heading3"], fontName="Helvetica-Bold", fontSize=11.5,
+                               leading=15, textColor=colors.HexColor("#B35A00"), spaceBefore=10,
+                               spaceAfter=4, alignment=TA_LEFT)
+styles["Body"] = ParagraphStyle("Body", parent=base["Normal"], fontName="Helvetica", fontSize=10,
+                                 leading=14.5, textColor=colors.black, alignment=TA_JUSTIFY,
+                                 spaceAfter=7)
+styles["Bullet"] = ParagraphStyle("Bullet", parent=styles["Body"], leftIndent=14, bulletIndent=2,
+                                   spaceAfter=5)
+styles["Caption"] = ParagraphStyle("Caption", parent=base["Normal"], fontName="Helvetica-Oblique",
+                                    fontSize=9, leading=12, textColor=GREY, alignment=TA_CENTER,
+                                    spaceAfter=10, spaceBefore=2)
+styles["Formula"] = ParagraphStyle("Formula", parent=base["Normal"], fontName="Courier-Bold",
+                                    fontSize=10.5, leading=16, textColor=ACCENT, alignment=TA_CENTER,
+                                    backColor=colors.HexColor("#EEF3F9"), borderColor=ACCENT,
+                                    borderWidth=1, borderPadding=10, spaceBefore=8, spaceAfter=10)
+styles["CalloutLabel"] = ParagraphStyle("CalloutLabel", parent=base["Normal"], fontName="Helvetica-Bold",
+                                         fontSize=9.5, leading=13, textColor=colors.white,
+                                         backColor=colors.HexColor("#B35A00"), borderPadding=(4, 6, 4, 6),
+                                         alignment=TA_LEFT)
+styles["TOCHeading"] = ParagraphStyle("TOCHeading", parent=base["Heading1"], fontName="Helvetica-Bold",
+                                       fontSize=17, textColor=ACCENT, spaceAfter=14)
+
+
+def P(text, style="Body"):
+    return Paragraph(text, styles[style])
+
+
+def heading(text, level=1, bookmark=None):
+    if level == 1:
+        st = "H1"
+    elif level == 2:
+        st = "H2"
+    else:
+        st = "H3"
+    para = Paragraph(text, styles[st])
+    clean_text = (bookmark or text).replace(" ", " ").replace("&", "&")
+    para._bookmark_name = clean_text
+    para._bookmark_level = level
+    return para
+
+
+def bullet(text):
+    return Paragraph(f"•  {text}", styles["Bullet"])
+
+
+def formula(text):
+    return Table([[Paragraph(text, styles["Formula"])]], colWidths=[CONTENT_W],
+                 style=TableStyle([
+                     ("BOX", (0, 0), (-1, -1), 1, ACCENT),
+                     ("BACKGROUND", (0, 0), (-1, -1), colors.HexColor("#EEF3F9")),
+                     ("TOPPADDING", (0, 0), (-1, -1), 10),
+                     ("BOTTOMPADDING", (0, 0), (-1, -1), 10),
+                 ]))
+
+
+def data_table(headers, rows, col_widths=None, note=None):
+    if col_widths is None:
+        col_widths = [CONTENT_W / len(headers)] * len(headers)
+    header_row = [Paragraph(f"<b>{h}</b>", ParagraphStyle("th", parent=base["Normal"], fontName="Helvetica-Bold",
+                                                            fontSize=9.5, textColor=colors.white, alignment=TA_CENTER))
+                  for h in headers]
+    body_rows = []
+    for row in rows:
+        cells = []
+        for i, val in enumerate(row):
+            align = TA_LEFT if i == 0 else TA_CENTER
+            cells.append(Paragraph(str(val), ParagraphStyle("td", parent=base["Normal"], fontName="Helvetica",
+                                                              fontSize=9.5, alignment=align, leading=12.5)))
+        body_rows.append(cells)
+    data = [header_row] + body_rows
+    t = Table(data, colWidths=col_widths, repeatRows=1)
+    style_cmds = [
+        ("BACKGROUND", (0, 0), (-1, 0), ACCENT),
+        ("GRID", (0, 0), (-1, -1), 0.6, BORDER_GREY),
+        ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
+        ("TOPPADDING", (0, 0), (-1, -1), 5),
+        ("BOTTOMPADDING", (0, 0), (-1, -1), 5),
+        ("LEFTPADDING", (0, 0), (-1, -1), 6),
+        ("RIGHTPADDING", (0, 0), (-1, -1), 6),
+    ]
+    for r in range(1, len(data)):
+        if r % 2 == 0:
+            style_cmds.append(("BACKGROUND", (0, r), (-1, r), LIGHT_GREY))
+    t.setStyle(TableStyle(style_cmds))
+    flowables = [t]
+    if note:
+        flowables.append(Paragraph(note, styles["Caption"]))
+    return KeepTogether(flowables) if note else t
+
+
+def scaled_image(path, max_width):
+    with PILImage.open(path) as im:
+        w, h = im.size
+    ratio = h / w
+    return Image(path, width=max_width, height=max_width * ratio)
+
+
+def image_with_caption(path, max_width, caption):
+    img = scaled_image(path, max_width)
+    cap = Paragraph(caption, styles["Caption"])
+    return KeepTogether([img, cap])
+
+
+# ---------------------------------------------------------------------------
+# Doc template: cover (blank) + content (header/footer, TOC bookmarks)
+# ---------------------------------------------------------------------------
+REPORT_TITLE = "Knowledge Distillation on Banking77 — Group 85"
+
+
+def draw_cover_background(cv, doc_):
+    cv.saveState()
+    cv.setFillColor(ACCENT)
+    cv.rect(0, PAGE_H - 1.3 * cm, PAGE_W, 1.3 * cm, fill=1, stroke=0)
+    cv.setFillColor(ACCENT)
+    cv.rect(0, 0, PAGE_W, 0.6 * cm, fill=1, stroke=0)
+    cv.restoreState()
+
+
+def draw_content_frame(cv, doc_):
+    cv.saveState()
+    cv.setStrokeColor(BORDER_GREY)
+    cv.setLineWidth(0.6)
+    cv.line(MARGIN, PAGE_H - 1.15 * cm, PAGE_W - MARGIN, PAGE_H - 1.15 * cm)
+    cv.setFont("Helvetica", 8.5)
+    cv.setFillColor(GREY)
+    cv.drawString(MARGIN, PAGE_H - 0.95 * cm, "Conversational AI — Assignment-2 (PS1)")
+    cv.drawRightString(PAGE_W - MARGIN, PAGE_H - 0.95 * cm, "Group 85 — Knowledge Distillation Report")
+
+    cv.line(MARGIN, 1.1 * cm, PAGE_W - MARGIN, 1.1 * cm)
+    cv.setFont("Helvetica", 8.5)
+    cv.drawString(MARGIN, 0.75 * cm, "Knowledge_Distillation_Report_Group85.pdf")
+    cv.drawRightString(PAGE_W - MARGIN, 0.75 * cm, f"Page {doc_.page}")
+    cv.restoreState()
+
+
+class ReportDocTemplate(BaseDocTemplate):
+    def afterFlowable(self, flowable):
+        if hasattr(flowable, "_bookmark_name"):
+            text = flowable._bookmark_name
+            level = flowable._bookmark_level
+            key = f"bm_{id(flowable)}"
+            self.canv.bookmarkPage(key)
+            self.canv.addOutlineEntry(text, key, level - 1, level == 1)
+            self.notify("TOCEntry", (level - 1, text, self.page, key))
+
+
+doc = ReportDocTemplate(
+    OUT_PATH, pagesize=A4,
+    leftMargin=MARGIN, rightMargin=MARGIN, topMargin=MARGIN, bottomMargin=MARGIN,
+    title="Knowledge Distillation Report — Group 85",
+    author="Group 85 (R. Priji Rajendran, Reeve Chaitanya, Sahil Verma, Vankala N Sai Krishna Kumar)",
+    subject="Conversational AI — Assignment-2 (PS1): Knowledge Distillation on Banking77",
+)
+
+cover_frame = Frame(0, 0, PAGE_W, PAGE_H, id="cover", leftPadding=2.4 * cm, rightPadding=2.4 * cm,
+                     topPadding=3.2 * cm, bottomPadding=2.4 * cm)
+content_frame = Frame(MARGIN, MARGIN, CONTENT_W, PAGE_H - 2 * MARGIN - 0.3 * cm, id="content")
+
+doc.addPageTemplates([
+    PageTemplate(id="Cover", frames=[cover_frame], onPage=draw_cover_background),
+    PageTemplate(id="Content", frames=[content_frame], onPage=draw_content_frame),
+])
+
+story = []
+
+# ---------------------------------------------------------------------------
+# Cover page
+# ---------------------------------------------------------------------------
+story.append(Spacer(1, 1.4 * cm))
+story.append(P("CONVERSATIONAL AI", "CoverSub"))
+story.append(Spacer(1, 0.3 * cm))
+story.append(P("Knowledge Distillation on the Banking77 Intent Dataset", "CoverTitle"))
+story.append(P("Compressing a Fine-Tuned BERT Teacher into a Compact, CPU-Deployable Student Transformer", "CoverSub"))
+story.append(Spacer(1, 1.0 * cm))
+
+cover_info = Table(
+    [
+        [P("Course Name", "CoverLabel"), P("Conversational AI", "CoverValue")],
+        [P("Assignment", "CoverLabel"), P("Assignment-2 (PS1)", "CoverValue")],
+        [P("Group ID", "CoverLabel"), P("Group 85", "CoverValue")],
+        [P("Dataset", "CoverLabel"), P("PolyAI/banking77 (77-class banking intent classification)", "CoverValue")],
+    ],
+    colWidths=[4.5 * cm, 10.5 * cm],
+)
+cover_info.setStyle(TableStyle([
+    ("BOX", (0, 0), (-1, -1), 1, ACCENT),
+    ("INNERGRID", (0, 0), (-1, -1), 0.5, colors.HexColor("#B9C9DA")),
+    ("BACKGROUND", (0, 0), (0, -1), ACCENT_LIGHT),
+    ("TOPPADDING", (0, 0), (-1, -1), 7),
+    ("BOTTOMPADDING", (0, 0), (-1, -1), 7),
+    ("LEFTPADDING", (0, 0), (-1, -1), 10),
+]))
+story.append(cover_info)
+story.append(Spacer(1, 1.0 * cm))
+
+story.append(P("Team Members", "CoverLabel"))
+story.append(Spacer(1, 0.2 * cm))
+team_rows = [
+    ["Name", "BITS ID"],
+    ["R. Priji Rajendran", "2024AD05222"],
+    ["Reeve Chaitanya", "2024AD05225"],
+    ["Sahil Verma", "2024AD05230"],
+    ["Vankala N Sai Krishna Kumar", "2024AD05334"],
+]
+story.append(data_table(team_rows[0], team_rows[1:], col_widths=[9.5 * cm, 5.5 * cm]))
+story.append(Spacer(1, 1.4 * cm))
+story.append(P("Source notebook: knowledge_distillation_assignment.ipynb (fully executed, end-to-end)", "CoverMeta"))
+story.append(P("Environment: conda env agn_env · Python 3.12 · Apple Silicon (MPS + CPU)", "CoverMeta"))
+
+story.append(NextPageTemplate("Content"))
+story.append(PageBreak())
+
+# ---------------------------------------------------------------------------
+# Table of contents
+# ---------------------------------------------------------------------------
+story.append(P("Table of Contents", "TOCHeading"))
+toc = TableOfContents()
+toc.levelStyles = [
+    ParagraphStyle("TOC0", fontName="Helvetica-Bold", fontSize=11, leading=16, leftIndent=0, textColor=ACCENT),
+    ParagraphStyle("TOC1", fontName="Helvetica", fontSize=10, leading=14, leftIndent=14, textColor=GREY),
+]
+story.append(toc)
+story.append(PageBreak())
+
+# ---------------------------------------------------------------------------
+# 1. Executive Summary & System Architecture
+# ---------------------------------------------------------------------------
+story.append(heading("1.&nbsp; Executive Summary and System Architecture", 1))
+story.append(Spacer(1, 8))
+story.append(P(
+    "This report documents the design, implementation, and empirical evaluation of a knowledge "
+    "distillation pipeline that compresses a large, fine-tuned Transformer (“Teacher”) into a "
+    "compact, CPU-deployable Transformer (“Student”), on the PolyAI/banking77 dataset — a 77-class, "
+    "fine-grained banking-intent classification task with 10,003 training and 3,080 test utterances. "
+    "The complete pipeline was implemented and executed end-to-end in a single Jupyter notebook "
+    "(<b>knowledge_distillation_assignment.ipynb</b>) inside the conda environment <b>agn_env</b> "
+    "(Python 3.12) on Apple Silicon; the Teacher was fine-tuned with MPS acceleration, while the Student "
+    "was deliberately trained and benchmarked entirely on CPU — the profile it is designed to be "
+    "deployed under."
+))
+story.append(P(
+    "<b>Pipeline overview:</b> <b>bert-base-uncased</b> (110M parameters) is fine-tuned end-to-end on "
+    "banking77 to serve as the Teacher. Its full 77-way softmax distribution (“soft labels”) is cached "
+    "for every training example. A custom, hand-built 4-layer encoder-only Transformer — using its own "
+    "compact, domain-trained WordPiece tokenizer — is then trained as the Student, using a combined "
+    "Kullback–Leibler (KL) divergence + cross-entropy loss that blends the Teacher's soft labels with the "
+    "ground-truth hard labels. A second, architecturally identical Student is trained on hard labels only, "
+    "as a control, to isolate the effect of distillation itself."
+))
+story.append(P(
+    "<b>Motivation for edge-oriented compression:</b> a 110M-parameter, ~420MB BERT checkpoint is "
+    "frequently impractical to ship inside a mobile app, run on a low-RAM edge device, or serve at low "
+    "latency on constrained hardware. Knowledge distillation offers a route to recover most of that "
+    "model's task accuracy in a footprint small enough for such environments, by training the small model "
+    "against the large model's full output distribution rather than only its predicted class — the "
+    "technique explored and quantified throughout this report."
+))
+
+arch_rows = [
+    ["Component", "Specification"],
+    ["Teacher", "bert-base-uncased, fine-tuned 3 epochs on banking77 (109,541,453 parameters)"],
+    ["Student", "Custom 4-layer encoder-only Transformer, hidden size 256, 4 heads (2,904,397 parameters)"],
+    ["Student tokenizer", "WordPiece, 3,000-token vocabulary, trained from scratch on the banking77 corpus"],
+    ["Distillation loss", "α·T²·KL(soft student ‖ soft teacher) + (1−α)·CE(student, true label), T=4.0, α=0.7"],
+    ["Training devices", "Teacher: Apple MPS · Student: CPU (training and inference)"],
+]
+story.append(Spacer(1, 4))
+story.append(data_table(arch_rows[0], arch_rows[1:], col_widths=[3.6 * cm, 11.4 * cm]))
+
+story.append(PageBreak())
+
+# ---------------------------------------------------------------------------
+# 2. Module 1
+# ---------------------------------------------------------------------------
+story.append(heading("2.&nbsp; Module 1: Teacher Labeling and Student Setup", 1))
+
+story.append(heading("2.1&nbsp; Task 1 Analysis — Soft Labels, Temperature, and Dark Knowledge", 2))
+story.append(P(
+    "bert-base-uncased was fine-tuned end-to-end on banking77 (3 epochs, batch size 32, learning rate "
+    "3e-5, weight decay 0.01, Hugging Face Trainer on MPS). After fine-tuning, one no-gradient forward "
+    "pass was run over the full, unshuffled training set to cache the Teacher's raw 77-dimensional "
+    "logits for every example — the “soft labels” used for distillation."
+))
+story.append(data_table(
+    ["Metric (test set)", "Value"],
+    [["Evaluation loss", "0.839"], ["Accuracy", "87.56%"], ["Macro F1", "0.868"],
+     ["Total parameters", "109,541,453"], ["Cached logits shape (train / test)", "[10,003 × 77] / [3,080 × 77]"]],
+    col_widths=[6.5 * cm, 8.5 * cm],
+))
+story.append(heading("Why soft labels carry “dark knowledge”", 3))
+story.append(P(
+    "A one-hot hard label for “I am still waiting on my card?” states only that the correct class is "
+    "<i>card_arrival</i>, and that every other one of the 77 classes is equally, absolutely wrong. That is "
+    "not what the Teacher believes: its softmax output might place 62% probability on <i>card_arrival</i>, "
+    "21% on the closely related <i>card_delivery_estimate</i>, and small residual mass elsewhere — it "
+    "still predicts the right class, but it also encodes how confusable the other intents are with it."
+))
+story.append(bullet("<b>Transfers inter-class similarity structure</b> — the relative magnitude of non-target probabilities is a learned “confusion prior” that a one-hot vector cannot express, which matters a great deal on a taxonomy with many near-duplicate intents like banking77's (e.g. <i>declined_card_payment</i> vs. <i>declined_cash_withdrawal</i>)."))
+story.append(bullet("<b>Acts as an implicit regularizer</b> — a smoother, higher-entropy target does not force the Student's logits toward extreme values to satisfy a one-hot target, improving generalization, especially for a Student with a very small parameter budget."))
+story.append(bullet("<b>Supplies more effective supervision per example</b> — a hard label carries at most log₂(77) ≈ 6.3 bits of information; a full probability vector carries substantially more, letting a smaller, more data-constrained Student recover more of the Teacher's decision surface from the same training set."))
+story.append(bullet("<b>Is amplified by temperature scaling (T)</b> — dividing both models' logits by T &gt; 1 before the softmax flattens both distributions, inflating the small probabilities on non-target classes — exactly where most of the structural “dark knowledge” lives, since at T=1 those probabilities are too close to zero to produce a useful gradient. This project uses T = 4.0 (Task 4)."))
+
+story.append(heading("2.2&nbsp; Task 2 Analysis — Tokenizer Alignment Between Teacher and Student", 2))
+story.append(P(
+    "Rather than reusing the Teacher's ~30k-token BERT vocabulary, the Student is given its own compact "
+    "WordPiece tokenizer, trained from scratch directly on the banking77 training corpus (target "
+    "vocabulary size 3,000, BERT-style lowercasing, [CLS]/[SEP] template post-processing). This is a "
+    "deliberate compression lever: embedding-table size scales with vocab_size × hidden_size, so a "
+    "10x-smaller, domain-concentrated vocabulary directly shrinks the Student's parameter count "
+    "(quantified in Task 3)."
+))
+story.append(data_table(
+    ["Property", "Teacher (BERT)", "Student (custom WordPiece)"],
+    [["Vocabulary size", "30,522", "3,000"], ["Vocabulary compression", "—", "10.2x smaller"]],
+    col_widths=[5.5 * cm, 4.5 * cm, 5.0 * cm],
+))
+story.append(Spacer(1, 4))
+story.append(data_table(
+    ["Sample utterance", "Teacher tokens", "Student tokens (incl. [CLS]/[SEP])"],
+    [
+        ["“I am still waiting on my card?”", "8", "10"],
+        ["“What can I do if my card still hasn't arrived...”", "16", "18"],
+        ["“I have been waiting over a week. Is the card...”", "14", "16"],
+        ["“Can I track my card while it is in the process...”", "14", "16"],
+        ["“How do I know if I will get my card, or if it...”", "17", "19"],
+    ],
+    col_widths=[8.5 * cm, 3.0 * cm, 3.5 * cm],
+))
+story.append(heading("Alignment strategy", 3))
+story.append(P(
+    "On these five common, in-domain examples the Student's token count equals the Teacher's plus exactly "
+    "two — the [CLS]/[SEP] markers the Student's counts include and the Teacher's tokenize() call does "
+    "not — meaning the two vocabularies segment frequent, in-domain phrasing about equally coarsely. The "
+    "cost of the much smaller vocabulary shows up on rarer or compound words, via more aggressive subword "
+    "splitting and a higher effective [UNK] rate, rather than on everyday vocabulary."
+))
+story.append(P(
+    "A more fundamental design question is how to align a Teacher and Student that tokenize the same text "
+    "differently. A naive token-level distillation scheme — as used for sequence-to-sequence or "
+    "token-classification tasks — requires the two models' output sequences to line up position-by-position, "
+    "which breaks immediately once tokenizers disagree on token counts. That problem does not apply here, "
+    "because this is <b>sequence classification</b>: the Teacher emits exactly one 77-way probability "
+    "vector per example, independent of its internal token count. The only alignment that matters is "
+    "therefore at the <b>example (row) level</b>:"
+))
+story.append(bullet("<b>Strategy used</b> — Teacher logits are computed once per raw-text example and cached, indexed by that example's position in the unshuffled training set. The same raw text is independently re-tokenized with the Student's own tokenizer. The two are joined purely by row index inside the training Dataset class, so teacher_logits[i] always corresponds to example i regardless of how differently each side tokenized its text."))
+story.append(bullet("<b>Residual risk and mitigation</b> — a much smaller vocabulary can lose lexical signal on rare words; this is mitigated by training the Student tokenizer directly on in-domain banking77 text, so its limited token budget is spent on vocabulary that actually matters for this task."))
+
+story.append(PageBreak())
+
+# ---------------------------------------------------------------------------
+# 3. Module 2
+# ---------------------------------------------------------------------------
+story.append(heading("3.&nbsp; Module 2: Distillation Architecture and Training Details", 1))
+
+story.append(heading("3.1&nbsp; Task 3 — Compact Student Transformer Architecture", 2))
+story.append(P(
+    "The Student is a small, hand-built encoder-only Transformer, assembled directly from PyTorch "
+    "<b>nn.Module</b> / <b>nn.TransformerEncoderLayer</b> primitives rather than repurposing a pretrained "
+    "architecture, and sized to train and run comfortably on CPU."
+))
+story.append(data_table(
+    ["Architecture parameter", "Value"],
+    [
+        ["Vocabulary size", "3,000 (Task 2 tokenizer)"], ["Hidden size", "256"], ["Encoder layers", "4"],
+        ["Attention heads", "4"], ["Feed-forward size", "512"], ["Max sequence length", "32"],
+        ["Dropout", "0.1"], ["Pooling", "Mean-pooling over non-padding token positions"],
+        ["Output head", "Linear layer to 77 classes"],
+    ],
+    col_widths=[6.0 * cm, 9.0 * cm],
+))
+story.append(heading("Parameter breakdown vs. Teacher", 3))
+story.append(data_table(
+    ["Component", "Parameters"],
+    [
+        ["Token + position embeddings", "776,192"], ["Transformer encoder (4 layers)", "2,108,416"],
+        ["Classification head", "19,789"], ["Student total", "<b>2,904,397</b>"],
+        ["Teacher total (bert-base-uncased)", "<b>109,541,453</b>"],
+        ["Compression ratio", "<b>37.7x fewer parameters</b>"],
+    ],
+    col_widths=[8.0 * cm, 7.0 * cm],
+))
+story.append(P(
+    "Roughly 27% of the Student's parameter budget sits in its embedding table alone — the direct payoff "
+    "of Task 2's small, domain-specific vocabulary. Because a Transformer's parameter count for "
+    "short-sequence classification scales with vocab_size × hidden_size, shrinking the vocabulary is one "
+    "of the single highest-leverage compression decisions available, independent of encoder depth or width."
+))
+
+story.append(heading("3.2&nbsp; Task 4 — Distillation Loss Function", 2))
+story.append(P("The Student is trained against a single combined objective, blending distillation and supervised signal:"))
+story.append(formula(
+    "Loss = α · T² · KL( P<sub>student</sub><sup>T</sup> ‖ P<sub>teacher</sub><sup>T</sup> ) "
+    "+ (1−α) · CE( y<sub>student</sub>, y<sub>true</sub> )"
+))
+story.append(P(
+    "with temperature <b>T = 4.0</b> and weighting <b>α = 0.7</b>. The KL term compares the Student's and "
+    "Teacher's softmax outputs after both are divided by T (softening both distributions and amplifying "
+    "the small, informative probabilities on non-target classes); the T² multiplier (Hinton et al., 2015) "
+    "compensates for the fact that raising T shrinks the KD gradient magnitude by roughly 1/T² relative to "
+    "the hard-label term, so without it the KD loss would be under-weighted once a large T is introduced. "
+    "The CE term is ordinary cross-entropy against the true label, ensuring the Student never loses sight "
+    "of the actual classification objective while learning to mimic the Teacher's distribution."
+))
+story.append(heading("Training configuration", 3))
+story.append(data_table(
+    ["Hyperparameter", "Distilled Student", "Baseline Student (control)"],
+    [
+        ["Loss", "α·T²·KL + (1−α)·CE", "CE only (hard labels)"],
+        ["Optimizer", "AdamW, lr 3e-4", "AdamW, lr 3e-4"],
+        ["Epochs / batch size", "8 / 32", "8 / 32"],
+        ["Device", "CPU", "CPU"],
+        ["Training time", "130.8 s", "127.6 s"],
+    ],
+    col_widths=[4.5 * cm, 5.25 * cm, 5.25 * cm],
+))
+story.append(Spacer(1, 6))
+story.append(data_table(
+    ["Epoch", "Total loss", "KD component", "CE component"],
+    [
+        ["1", "1.142", "0.556", "2.508"], ["2", "0.559", "0.306", "1.150"],
+        ["3", "0.387", "0.217", "0.786"], ["4", "0.301", "0.174", "0.598"],
+        ["5", "0.248", "0.148", "0.482"], ["6", "0.211", "0.132", "0.396"],
+        ["7", "0.184", "0.118", "0.337"], ["8", "0.166", "0.110", "0.297"],
+    ],
+    col_widths=[2.5 * cm, 4.17 * cm, 4.17 * cm, 4.17 * cm],
+))
+story.append(image_with_caption(
+    f"{ASSETS}/distill_loss_curves.png", 13.5 * cm,
+    "Figure 1. Distilled student training: total loss (left) and its KD vs. CE components (right) across 8 epochs.",
+))
+story.append(P(
+    "The CE component drops faster and further than the KD component throughout training: with only "
+    "3,000 vocabulary tokens and 4 layers, the Student can quickly memorize the single correct class for a "
+    "small, well-separated training set, whereas matching the Teacher's full smoothed distribution over "
+    "77 classes at T=4 is a strictly harder target. The KD term keeps supplying a non-trivial gradient "
+    "signal well after the CE term has largely converged — exactly the regime in which distillation "
+    "contributes information beyond what hard labels alone would teach."
+))
+
+story.append(PageBreak())
+
+# ---------------------------------------------------------------------------
+# 4. Module 3
+# ---------------------------------------------------------------------------
+story.append(heading("4.&nbsp; Module 3: Experimental Results and Benchmarking", 1))
+
+story.append(heading("4.1&nbsp; Task 5 — Accuracy vs. Compression Evaluation", 2))
+story.append(P(
+    "To isolate the effect of distillation from the effect of the compact architecture alone, a second, "
+    "architecturally identical Student is trained with plain cross-entropy on ground-truth labels only "
+    "(no Teacher signal). All three models are evaluated on the same held-out 3,080-example test set using "
+    "scikit-learn's accuracy_score and f1_score (macro and weighted)."
+))
+story.append(data_table(
+    ["Model", "Accuracy", "Macro F1", "Weighted F1"],
+    [
+        ["Teacher (bert-base-uncased)", "87.56%", "0.868", "0.868"],
+        ["Student — without distillation", "83.47%", "0.836", "0.836"],
+        ["Student — with distillation", "<b>87.44%</b>", "<b>0.874</b>", "<b>0.874</b>"],
+    ],
+    col_widths=[6.5 * cm, 3.0 * cm, 2.9 * cm, 2.9 * cm],
+))
+story.append(image_with_caption(
+    f"{ASSETS}/baseline_vs_distilled_loss.png", 9.5 * cm,
+    "Figure 2. Training loss: baseline student (CE only) vs. distilled student (KD + CE). The two loss compositions are not directly comparable in scale.",
+))
+story.append(P(
+    "The undistilled Student, trained only on hard labels with a 37.7x smaller architecture, reaches "
+    "83.5% accuracy — a 4.1-point gap below the Teacher's 87.6%, as expected given how much capacity was "
+    "removed. Adding the Teacher's soft labels — architecture, data, and epoch budget held fixed, "
+    "changing only the loss function — raises the Student to 87.4% accuracy, <b>closing 97% of the "
+    "accuracy gap</b> between the undistilled Student and the Teacher, and retaining <b>99.9%</b> of the "
+    "Teacher's accuracy at a fraction of its parameter count. This is the central empirical claim of "
+    "knowledge distillation demonstrated directly: dark knowledge in the Teacher's soft labels lets a "
+    "small model recover far more of a large model's decision surface than the same small model could "
+    "learn from hard labels alone. This closeness also partly reflects that the Teacher itself is only a "
+    "lightly (3-epoch) fine-tuned model and the test set is a few thousand examples — a point or two either "
+    "way is within normal run-to-run variance."
+))
+
+story.append(heading("4.2&nbsp; Task 6 — Deployment Metrics Benchmarking", 2))
+story.append(P(
+    "Accuracy alone does not determine deployability. Three deployment-relevant metrics were measured for "
+    "the Teacher and the distilled Student: on-disk model size, CPU inference latency, and peak process "
+    "RAM. Peak RAM was measured in an <b>isolated subprocess per model</b> (via resource.getrusage) rather "
+    "than in the shared notebook kernel, since peak RSS is monotonically non-decreasing for the life of a "
+    "process — loading both models into one kernel would let the Teacher's larger footprint contaminate "
+    "any subsequent reading taken for the Student."
+))
+story.append(data_table(
+    ["Metric", "Teacher", "Student", "Compression / Speedup"],
+    [
+        ["Model size on disk (MB)", "417.9", "11.1", "<b>37.7x smaller</b>"],
+        ["CPU inference latency (ms/query)", "27.76 ± 3.07", "1.18 ± 0.09", "<b>23.5x faster</b>"],
+        ["Peak RAM (MB, isolated process)", "893.8", "237.0", "<b>3.8x smaller</b>"],
+    ],
+    col_widths=[5.5 * cm, 3.0 * cm, 3.0 * cm, 3.8 * cm],
+))
+
+story.append(PageBreak())
+
+# ---------------------------------------------------------------------------
+# 5. Deployment Readiness
+# ---------------------------------------------------------------------------
+story.append(heading("5.&nbsp; Deployment Readiness and Engineering Inferences", 1))
+story.append(P(
+    "The distilled Student is <b>37.7x smaller on disk</b>, <b>23.5x faster</b> per CPU query, and uses "
+    "<b>3.8x less peak RAM</b> than the Teacher, while retaining <b>99.9%</b> of its accuracy on the same "
+    "77-way classification task. In this run there is essentially no accuracy cost to weigh against those "
+    "savings — a favourable outcome rather than a guarantee, since it partly reflects a lightly fine-tuned "
+    "Teacher and a modest-size test set; a production rollout should still monitor accuracy on live "
+    "traffic rather than assume this margin holds indefinitely as the input distribution drifts."
+))
+story.append(bullet("<b>Size and RAM</b> — at ~11MB on disk and ~237MB of peak RAM, the Student comfortably fits within the memory budgets of edge devices and mobile apps, where a 418MB+ BERT-base checkpoint is frequently a non-starter (app-store bundle-size limits, low-RAM Android devices, on-device model caches)."))
+story.append(bullet("<b>Latency</b> — 1.2ms/query on CPU is well within the range needed for a responsive, synchronous UI interaction (e.g. intent routing as a user types), whereas the Teacher's 27.8ms/query, multiplied across a request queue on a resource-constrained device, would noticeably degrade perceived responsiveness."))
+story.append(bullet("<b>Accuracy trade-off</b> — in this run there is effectively no trade-off; the size/latency/RAM wins come essentially for free on this test set. Whether that generalizes depends on the product: for a first-pass intent router that falls back to a human agent or a larger cloud model on low confidence, distillation is a clear win even when some accuracy gap does exist. For a fully autonomous decision with no fallback (e.g. auto-approving a refund), any residual gap to the Teacher may still argue for keeping the Teacher, or a human, in the loop."))
+story.append(bullet("<b>Practical recommendation</b> — deploy the distilled Student as the default path, and route low-confidence predictions (small margin between the top-2 softmax probabilities) to the Teacher or a human reviewer. This captures most of the demonstrated size/latency/RAM benefits while bounding accuracy risk to only the genuinely ambiguous cases — exactly the scenario dark-knowledge distillation is suited for, since the Student was trained to mimic the Teacher's confidence structure, not just its arg-max."))
+
+story.append(heading("Key takeaways", 2))
+story.append(bullet("<b>Dark knowledge transfers real signal</b> — distillation closed 97% of the accuracy gap between an undistilled and a distilled Student sharing the same 37.7x-smaller architecture, using only a change of loss function — no additional data, parameters, or training time."))
+story.append(bullet("<b>Vocabulary size is a first-order compression lever</b> — a domain-trained, 10x-smaller Student tokenizer removed roughly a quarter of the Student's total parameter budget on its own, independent of encoder depth or width."))
+story.append(bullet("<b>Sequence-classification distillation avoids the hardest alignment problem</b> — because the Teacher produces one probability vector per example rather than per token, tokenizer mismatch only requires row-level index alignment, not token-level alignment."))
+story.append(bullet("<b>The compression payoff is large and, in this run, the accuracy cost is negligible</b> — 37.7x smaller, 23.5x faster, 3.8x less RAM, for 99.9% of the Teacher's test accuracy, making the distilled Student a strong candidate for edge/mobile deployment, ideally paired with a confidence-based fallback to the Teacher for the hardest cases."))
+
+
+doc.multiBuild(story)
+print(f"PDF written to {OUT_PATH}")

demo/build_report.py

@@ -0,0 +1,688 @@
+"""Builds Knowledge_Distillation_Report.docx summarizing design, implementation, and evaluation."""
+import datetime
+from docx import Document
+from docx.shared import Pt, Inches, RGBColor, Cm
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+from docx.enum.table import WD_TABLE_ALIGNMENT
+from docx.oxml.ns import qn
+from docx.oxml import OxmlElement
+
+ASSETS = "/Users/reevechaitanya/Documents/2_Experimentation_n_Research/demo/report_assets"
+
+ACCENT = RGBColor(0x1F, 0x4E, 0x79)
+GREY = RGBColor(0x40, 0x40, 0x40)
+
+doc = Document()
+
+# ---------------------------------------------------------------------------
+# Global style setup
+# ---------------------------------------------------------------------------
+normal = doc.styles["Normal"]
+normal.font.name = "Calibri"
+normal.font.size = Pt(11)
+normal.paragraph_format.space_after = Pt(8)
+normal.paragraph_format.line_spacing = 1.15
+
+for i in range(1, 4):
+    h = doc.styles[f"Heading {i}"]
+    h.font.name = "Calibri"
+    h.font.color.rgb = ACCENT
+    h.font.bold = True
+h1, h2, h3 = doc.styles["Heading 1"], doc.styles["Heading 2"], doc.styles["Heading 3"]
+h1.font.size, h2.font.size, h3.font.size = Pt(20), Pt(15), Pt(12.5)
+h1.paragraph_format.space_before, h2.paragraph_format.space_before, h3.paragraph_format.space_before = Pt(20), Pt(14), Pt(10)
+
+for sec in doc.sections:
+    sec.left_margin = Cm(2.2)
+    sec.right_margin = Cm(2.2)
+    sec.top_margin = Cm(1.8)
+    sec.bottom_margin = Cm(1.8)
+
+
+def add_page_number_footer(section):
+    footer = section.footer
+    p = footer.paragraphs[0]
+    p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    run = p.add_run()
+    fld = OxmlElement("w:fldSimple")
+    fld.set(qn("w:instr"), "PAGE")
+    run._r.append(fld)
+
+
+add_page_number_footer(doc.sections[0])
+
+
+def h(text, level=1):
+    doc.add_heading(text, level=level)
+
+
+def p(text="", bold=False, italic=False, size=None, color=None, align=None, space_after=None):
+    para = doc.add_paragraph()
+    if align is not None:
+        para.alignment = align
+    if space_after is not None:
+        para.paragraph_format.space_after = Pt(space_after)
+    run = para.add_run(text)
+    run.bold = bold
+    run.italic = italic
+    if size:
+        run.font.size = Pt(size)
+    if color:
+        run.font.color.rgb = color
+    return para
+
+
+def rich(para, segments):
+    """segments: list of (text, bold, italic) tuples appended to an existing paragraph."""
+    for seg in segments:
+        text = seg[0]
+        bold = seg[1] if len(seg) > 1 else False
+        italic = seg[2] if len(seg) > 2 else False
+        run = para.add_run(text)
+        run.bold = bold
+        run.italic = italic
+    return para
+
+
+def bullets(items):
+    # Special case used throughout this script: bullets([["Bold label", True], "plain description"])
+    # is ONE bullet with a bold lead-in run followed by a normal-weight continuation run.
+    if (len(items) == 2 and isinstance(items[0], (list, tuple)) and len(items[0]) == 2
+            and isinstance(items[0][1], bool) and isinstance(items[1], str)):
+        para = doc.add_paragraph(style="List Bullet")
+        label, bold = items[0]
+        lead_run = para.add_run(label)
+        lead_run.bold = bold
+        para.add_run(items[1])
+        return
+    for item in items:
+        para = doc.add_paragraph(style="List Bullet")
+        if isinstance(item, str):
+            para.add_run(item)
+        else:
+            rich(para, item)
+
+
+def formula_block(text):
+    para = doc.add_paragraph()
+    para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    para.paragraph_format.space_before = Pt(6)
+    para.paragraph_format.space_after = Pt(6)
+    run = para.add_run(text)
+    run.italic = True
+    run.font.size = Pt(12)
+    run.font.name = "Cambria Math"
+    return para
+
+
+def set_cell_shading(cell, hex_color):
+    tc_pr = cell._tc.get_or_add_tcPr()
+    shd = OxmlElement("w:shd")
+    shd.set(qn("w:val"), "clear")
+    shd.set(qn("w:fill"), hex_color)
+    tc_pr.append(shd)
+
+
+def add_table(headers, rows, col_widths=None, header_color="1F4E79"):
+    table = doc.add_table(rows=1, cols=len(headers))
+    table.style = "Table Grid"
+    table.alignment = WD_TABLE_ALIGNMENT.CENTER
+    hdr_cells = table.rows[0].cells
+    for i, htext in enumerate(headers):
+        hdr_cells[i].text = ""
+        run = hdr_cells[i].paragraphs[0].add_run(htext)
+        run.bold = True
+        run.font.color.rgb = RGBColor(0xFF, 0xFF, 0xFF)
+        run.font.size = Pt(10.5)
+        set_cell_shading(hdr_cells[i], header_color)
+        hdr_cells[i].paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
+    for row in rows:
+        cells = table.add_row().cells
+        for i, val in enumerate(row):
+            cells[i].text = ""
+            run = cells[i].paragraphs[0].add_run(str(val))
+            run.font.size = Pt(10.5)
+            cells[i].paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER if i > 0 else WD_ALIGN_PARAGRAPH.LEFT
+    if col_widths:
+        for i, w in enumerate(col_widths):
+            for row in table.rows:
+                row.cells[i].width = Inches(w)
+    doc.add_paragraph()
+    return table
+
+
+def add_image(path, width=5.8, caption=None):
+    doc.add_picture(path, width=Inches(width))
+    last_paragraph = doc.paragraphs[-1]
+    last_paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+    if caption:
+        cap = doc.add_paragraph()
+        cap.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        run = cap.add_run(caption)
+        run.italic = True
+        run.font.size = Pt(9.5)
+        run.font.color.rgb = GREY
+
+
+# ---------------------------------------------------------------------------
+# Title page
+# ---------------------------------------------------------------------------
+title_p = doc.add_paragraph()
+title_p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+title_p.paragraph_format.space_before = Pt(120)
+run = title_p.add_run("Knowledge Distillation on the Banking77 Intent Dataset")
+run.bold = True
+run.font.size = Pt(26)
+run.font.color.rgb = ACCENT
+
+sub_p = doc.add_paragraph()
+sub_p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+sub_p.paragraph_format.space_before = Pt(10)
+run = sub_p.add_run("Design, Implementation, and Evaluation Report")
+run.font.size = Pt(16)
+run.font.color.rgb = GREY
+
+sub2 = doc.add_paragraph()
+sub2.alignment = WD_ALIGN_PARAGRAPH.CENTER
+sub2.paragraph_format.space_before = Pt(4)
+run = sub2.add_run("Compressing a Fine-Tuned BERT Teacher into a Compact CPU-Deployable Transformer Student")
+run.font.size = Pt(12)
+run.italic = True
+run.font.color.rgb = GREY
+
+meta_p = doc.add_paragraph()
+meta_p.alignment = WD_ALIGN_PARAGRAPH.CENTER
+meta_p.paragraph_format.space_before = Pt(60)
+meta_lines = [
+    f"Generated: {datetime.date.today().strftime('%B %d, %Y')}",
+    "Source notebook: knowledge_distillation_assignment.ipynb",
+    "Dataset: PolyAI/banking77 (77-class banking intent classification)",
+    "Environment: conda env agn_env, Python 3.12, Apple Silicon (MPS + CPU)",
+]
+for i, line in enumerate(meta_lines):
+    if i > 0:
+        meta_p.add_run("\n")
+    r = meta_p.add_run(line)
+    r.font.size = Pt(11)
+    r.font.color.rgb = GREY
+
+doc.add_page_break()
+
+# ---------------------------------------------------------------------------
+# 1. Introduction
+# ---------------------------------------------------------------------------
+h("1. Introduction and Objective", 1)
+p(
+    "Large fine-tuned Transformers such as BERT deliver strong accuracy on text classification tasks but "
+    "are frequently too large, too slow, and too memory-hungry to deploy on edge devices, mobile "
+    "applications, or latency-sensitive services. Knowledge distillation addresses this by transferring "
+    "the behaviour of a large “Teacher” model into a much smaller “Student” model, using the "
+    "Teacher's full output probability distribution — not just its predicted class — as a richer training "
+    "signal."
+)
+p(
+    "This report documents the design, implementation, and evaluation of an end-to-end knowledge "
+    "distillation pipeline built for the 77-class Banking77 intent-classification dataset, structured "
+    "around three modules and six tasks:"
+)
+add_table(
+    ["Module", "Tasks"],
+    [
+        ["1. Teacher Labeling & Student Setup", "Task 1: Teacher fine-tuning & soft-label generation\nTask 2: Student tokenizer alignment"],
+        ["2. Distillation Architecture & Training", "Task 3: Compact student transformer\nTask 4: Distillation loss function & training"],
+        ["3. Comparative Analysis & Benchmarking", "Task 5: Accuracy vs. compression evaluation\nTask 6: Deployment metrics analysis"],
+    ],
+    col_widths=[2.6, 3.7],
+)
+p(
+    "All code was implemented and executed end-to-end in a single Jupyter notebook "
+    "(knowledge_distillation_assignment.ipynb) inside the conda environment agn_env (Python 3.12) on an "
+    "Apple Silicon machine. The Teacher was fine-tuned using MPS acceleration; the Student was deliberately "
+    "trained and benchmarked entirely on CPU, since CPU-only inference is the target deployment profile "
+    "this exercise is optimizing for."
+)
+
+# ---------------------------------------------------------------------------
+# 2. Dataset
+# ---------------------------------------------------------------------------
+h("2. Dataset", 1)
+p(
+    "Banking77 is a fine-grained intent-classification dataset of customer-support utterances for a "
+    "banking app, labelled with one of 77 narrow, often semantically overlapping intents (e.g. "
+    "card_arrival vs. card_delivery_estimate, declined_card_payment vs. declined_cash_withdrawal). This "
+    "makes it a good stress test for distillation: the fine granularity of the label space means the "
+    "relative similarity between classes — the information that soft labels carry and hard labels do "
+    "not — is directly relevant to classification accuracy."
+)
+add_table(
+    ["Property", "Value"],
+    [
+        ["Source", "PolyAI/banking77 (loaded via a verified parquet mirror, legacy-datasets/banking77, after the original repository's script-based loader was found incompatible with the installed datasets library version)"],
+        ["Training examples", "10,003"],
+        ["Test examples", "3,080"],
+        ["Number of classes", "77"],
+        ["Example text", "“I am still waiting on my card?” → label: card_arrival"],
+    ],
+    col_widths=[2.0, 4.3],
+)
+
+doc.add_page_break()
+
+# ---------------------------------------------------------------------------
+# Module 1
+# ---------------------------------------------------------------------------
+h("3. Module 1: Teacher Labeling and Student Setup", 1)
+
+h("3.1 Task 1 — Teacher Integration and Soft-Label Generation", 2)
+
+h("Design", 3)
+p(
+    "bert-base-uncased (110M parameters) was selected as the Teacher for its strong general-purpose "
+    "language representations and its established track record on intent-classification benchmarks. "
+    "The design goal was twofold: (1) fine-tune it into a strong classifier for banking77, and (2) cache "
+    "its full 77-way probability distribution — not just its hard prediction — for every training "
+    "example, so that the Student never needs the (comparatively expensive) Teacher to run again during "
+    "its own training."
+)
+
+h("Implementation", 3)
+bullets([
+    "Tokenization: bert-base-uncased's own WordPiece tokenizer, sequences truncated to 64 tokens.",
+    "Model: transformers.BertForSequenceClassification.from_pretrained(\"bert-base-uncased\", num_labels=77) — the pretrained encoder weights are kept; a new randomly-initialized 77-way classification head is trained from scratch.",
+    "Training: Hugging Face Trainer, 3 epochs, batch size 32 (train) / 64 (eval), learning rate 3e-5, weight decay 0.01, evaluated each epoch on the test set, run on Apple Silicon MPS.",
+    "Soft-label caching: one no-gradient forward pass over the full, unshuffled training set (and separately the test set) immediately after fine-tuning, producing a [10003 × 77] and a [3080 × 77] logits tensor respectively. Because the pass is unshuffled, teacher_train_logits[i] corresponds exactly to training example i by index — this index-based join is what Task 2 relies on.",
+])
+
+h("Results", 3)
+add_table(
+    ["Metric (test set)", "Value"],
+    [
+        ["Evaluation loss", "0.839"],
+        ["Accuracy", "87.6%"],
+        ["Macro F1", "0.868"],
+        ["Total parameters", "109,541,453"],
+        ["Cached train logits shape", "[10,003, 77]"],
+        ["Cached test logits shape", "[3,080, 77]"],
+    ],
+    col_widths=[3.0, 3.0],
+)
+
+h("Interpretation — Why Soft Labels Carry “Dark Knowledge”", 3)
+p(
+    "A one-hot hard label for “I am still waiting on my card?” states only that the correct class is "
+    "card_arrival and that all 76 other classes are equally, absolutely wrong. That is not what the "
+    "Teacher actually believes: its softmax distribution might place 62% probability on card_arrival, "
+    "21% on the closely related card_delivery_estimate, and small residual mass on a handful of other "
+    "intents. Training against the full distribution rather than the arg-max alone:"
+)
+bullets([
+    ["Transfers inter-class similarity structure. ", True],
+    "The relative magnitude of non-target probabilities encodes which intents the Teacher finds confusable with which — a signal entirely absent from a one-hot vector, and especially valuable on a taxonomy with many near-duplicate intents like banking77's.",
+])
+bullets([
+    ["Acts as an implicit regularizer. ", True],
+    "A smoother, higher-entropy target does not force the Student's logits toward extreme values to satisfy a one-hot target, which tends to improve generalization — particularly important for a Student with a very small parameter budget.",
+])
+bullets([
+    ["Supplies more effective supervision per example. ", True],
+    "A hard label carries at most log₂(77) ≈ 6.3 bits of information (which class); a full probability vector carries substantially more, letting a smaller, more data-constrained Student recover more of the Teacher's decision surface from the same training set.",
+])
+bullets([
+    ["Is amplified by temperature scaling. ", True],
+    "Raising the softmax temperature T before distillation (used in Task 4) inflates the small probabilities on non-target classes — exactly where most of this structural information lives, since at T=1 those probabilities are too close to zero to produce a useful gradient.",
+])
+
+h("3.2 Task 2 — Student Tokenizer Alignment", 2)
+
+h("Design", 3)
+p(
+    "Rather than reusing the Teacher's ~30k-token BERT vocabulary, the Student is given its own compact "
+    "WordPiece tokenizer trained from scratch, directly on the banking77 training corpus. This keeps the "
+    "Student's vocabulary small (a major lever on parameter count, since embedding-table size scales with "
+    "vocab_size × hidden_size) while concentrating that small vocabulary on the words that actually appear "
+    "in this domain."
+)
+
+h("Implementation", 3)
+bullets([
+    "Backend: tokenizers.Tokenizer with a WordPiece model, BERT-style lowercasing normalizer, whitespace pre-tokenizer, and [CLS]/[SEP] template post-processing.",
+    "Trained via WordPieceTrainer with a target vocabulary size of 3,000 tokens and special tokens [PAD], [UNK], [CLS], [SEP], directly on the 10,003 raw training utterances.",
+    "A helper (student_encode_batch) pads/truncates every example to a fixed 32-token sequence length for the Student's fixed-size batched forward pass.",
+])
+
+h("Results — Tokenizer Comparison", 3)
+add_table(
+    ["Property", "Teacher (BERT)", "Student (custom WordPiece)"],
+    [
+        ["Vocabulary size", "30,522", "3,000"],
+        ["Vocabulary compression", "—", "10.2x smaller"],
+    ],
+    col_widths=[2.4, 2.0, 2.4],
+)
+p("Side-by-side tokenization of five sample utterances:", bold=False)
+add_table(
+    ["Utterance (truncated)", "Teacher tokens", "Student tokens (incl. [CLS]/[SEP])"],
+    [
+        ["I am still waiting on my card?", "8", "10"],
+        ["What can I do if my card still hasn't arrived...", "16", "18"],
+        ["I have been waiting over a week. Is the card...", "14", "16"],
+        ["Can I track my card while it is in the process...", "14", "16"],
+        ["How do I know if I will get my card, or if it...", "17", "19"],
+    ],
+    col_widths=[3.6, 1.4, 1.9],
+)
+
+h("Interpretation — Handling the Vocabulary Mismatch", 3)
+p(
+    "On these five common, in-domain examples, the Student's token count is exactly the Teacher's count "
+    "plus two — the [CLS]/[SEP] markers the Student's tokens include and the Teacher's tokenize() call "
+    "does not. In other words, for frequent, in-vocabulary phrasing the domain-trained 3,000-token "
+    "vocabulary segments text about as coarsely as BERT's 30,522-token vocabulary; the cost of a much "
+    "smaller vocabulary shows up on rarer or compound words not well represented in the 10,003-example "
+    "training corpus, via more aggressive subword splitting and a higher effective [UNK] rate, rather "
+    "than on everyday vocabulary."
+)
+p(
+    "A more fundamental question this task addresses is how to align Teacher and Student when they "
+    "tokenize the same text differently. A naive token-level distillation scheme — as used in "
+    "sequence-to-sequence or token-classification distillation — requires the Teacher's and Student's "
+    "output sequences to line up position by position, which breaks immediately once the two tokenizers "
+    "produce different token counts for the same input. That problem does not apply here, because "
+    "distillation in this project is over sequence classification: the Teacher emits exactly one 77-way "
+    "probability vector per example, regardless of how many tokens that example was split into "
+    "internally. The only alignment that matters is therefore at the example level, not the token level:"
+)
+bullets([
+    ["Strategy used: ", True],
+    "Teacher logits are computed once per raw-text example (Task 1) and cached indexed by the example's position in the unshuffled training set. The same raw text is independently re-tokenized with the Student's own tokenizer for the Student's forward pass. The two are joined purely by row index inside BankingStudentDataset — teacher_train_logits[i] always corresponds to train_raw[i], irrespective of how differently each tokenizer segmented that row's text.",
+])
+bullets([
+    ["Residual risk and mitigation: ", True],
+    "A much smaller vocabulary does risk losing lexical signal on rare words the Teacher could represent more precisely. This is mitigated by training the Student tokenizer directly on in-domain banking77 text, so its limited token budget is spent on the vocabulary that actually matters for this task rather than a generic corpus.",
+])
+
+doc.add_page_break()
+
+# ---------------------------------------------------------------------------
+# Module 2
+# ---------------------------------------------------------------------------
+h("4. Module 2: Distillation Architecture and Training", 1)
+
+h("4.1 Task 3 — Compact Student Transformer Construction", 2)
+
+h("Design", 3)
+p(
+    "The Student is a small, hand-built encoder-only Transformer — assembled directly from PyTorch "
+    "nn.Module / nn.TransformerEncoderLayer primitives rather than reusing a pretrained architecture — "
+    "sized deliberately small enough to train and run comfortably on CPU."
+)
+add_table(
+    ["Architecture parameter", "Value"],
+    [
+        ["Vocabulary size", "3,000 (Task 2 tokenizer)"],
+        ["Hidden size", "256"],
+        ["Encoder layers", "4"],
+        ["Attention heads", "4"],
+        ["Feed-forward size", "512"],
+        ["Max sequence length", "32"],
+        ["Dropout", "0.1"],
+        ["Pooling", "Mean-pooling over non-padding token positions"],
+        ["Output head", "Linear layer to 77 classes"],
+    ],
+    col_widths=[2.6, 3.7],
+)
+
+h("Implementation", 3)
+p(
+    "Forward pass: token embeddings and learned positional embeddings are summed, passed through 4 "
+    "stacked TransformerEncoderLayers with a padding mask (src_key_padding_mask) derived from the "
+    "attention mask so padded positions are ignored by self-attention, mean-pooled over valid (non-pad) "
+    "token positions, and projected through a linear classifier to 77 logits."
+)
+
+h("Results — Parameter Breakdown", 3)
+add_table(
+    ["Component", "Parameters"],
+    [
+        ["Token + position embeddings", "776,192"],
+        ["Transformer encoder (4 layers)", "2,108,416"],
+        ["Classification head", "19,789"],
+        ["Student total", "2,904,397"],
+        ["Teacher total (bert-base-uncased)", "109,541,453"],
+        ["Compression ratio", "37.7x fewer parameters"],
+    ],
+    col_widths=[3.4, 2.9],
+)
+
+h("Interpretation", 3)
+p(
+    "The Student uses 37.7x fewer parameters than the Teacher. Roughly 27% of that budget sits in the "
+    "embedding table alone — the direct payoff of Task 2's small, domain-specific vocabulary (3,000 vs. "
+    "BERT's 30,522 tokens). Because a Transformer's parameter count for short-sequence classification "
+    "scales with vocab_size × hidden_size, shrinking the vocabulary is one of the single highest-leverage "
+    "compression decisions available, independent of how many encoder layers are ultimately kept."
+)
+
+h("4.2 Task 4 — Distillation Loss Function", 2)
+
+h("Design", 3)
+p("The Student is trained with a combined objective:")
+formula_block(
+    "Loss = α · T² · KL(Pᵨtudent, Pᵀeacher at temperature T)  +  (1 − α) · CE(yᵨtudent, yᵀrue)"
+)
+p(
+    "with temperature T = 4.0 and weighting α = 0.7. The KL term is computed between the Student's and "
+    "Teacher's softmax distributions after both are divided by T (which softens both distributions and "
+    "amplifies the small, informative probabilities on non-target classes); the T² multiplier (Hinton et "
+    "al., 2015) compensates for the fact that raising T shrinks the magnitude of the gradients coming from "
+    "the soft-label term by roughly 1/T² relative to the hard-label term, so without it the KD loss would "
+    "be under-weighted once a large T is introduced. The CE term is ordinary cross-entropy against the "
+    "true ground-truth label, ensuring the Student never loses sight of the actual classification "
+    "objective even while learning to mimic the Teacher's distribution."
+)
+
+h("Implementation", 3)
+bullets([
+    "DistillationLoss(nn.Module): computes log_softmax(student_logits / T), softmax(teacher_logits / T), combines them via nn.KLDivLoss(reduction=\"batchmean\") scaled by T², and blends with nn.CrossEntropyLoss(student_logits, true_labels) using the α / (1−α) weights above.",
+    "BankingStudentDataset joins each example's Student-tokenized input with its cached Teacher logits and true label by row index (the alignment strategy from Task 2).",
+    "Training loop: AdamW optimizer, learning rate 3e-4, batch size 32, 8 epochs, executed entirely on CPU.",
+])
+
+h("Results", 3)
+add_table(
+    ["Epoch", "Total loss", "KD component", "CE component"],
+    [
+        ["1", "1.142", "0.556", "2.508"],
+        ["2", "0.559", "0.306", "1.150"],
+        ["3", "0.387", "0.217", "0.786"],
+        ["4", "0.301", "0.174", "0.598"],
+        ["5", "0.248", "0.148", "0.482"],
+        ["6", "0.211", "0.132", "0.396"],
+        ["7", "0.184", "0.118", "0.337"],
+        ["8", "0.166", "0.110", "0.297"],
+    ],
+    col_widths=[1.0, 1.8, 1.9, 1.9],
+)
+p(f"Total distilled-student training time: 130.8 seconds on CPU (8 epochs, 10,003 examples).")
+add_image(f"{ASSETS}/distill_loss_curves.png", width=6.2,
+           caption="Figure 1. Distilled student training: total loss (left) and its KD vs. CE components (right) across 8 epochs.")
+
+h("Interpretation", 3)
+p(
+    "The CE component drops faster and further than the KD component throughout training. This is "
+    "expected: with only 3,000 vocabulary tokens and 4 layers, the Student can quickly memorize the "
+    "single correct class for a small, reasonably well-separated training set, whereas matching the "
+    "Teacher's full smoothed distribution over 77 classes at T=4 is a strictly harder target. The KD term "
+    "keeps supplying a non-trivial gradient signal well after the CE term has largely converged — this is "
+    "exactly the regime in which distillation contributes information beyond what hard labels alone would "
+    "teach the Student."
+)
+
+doc.add_page_break()
+
+# ---------------------------------------------------------------------------
+# Module 3
+# ---------------------------------------------------------------------------
+h("5. Module 3: Comparative Analysis and Benchmarking", 1)
+
+h("5.1 Task 5 — Accuracy vs. Compression Evaluation", 2)
+
+h("Design", 3)
+p(
+    "To isolate the effect of distillation itself from the effect of the compact architecture, a second "
+    "“baseline” Student is trained: identical architecture, identical tokenizer, identical optimizer "
+    "and epoch budget as the distilled Student, but trained with plain cross-entropy against ground-truth "
+    "labels only, with no Teacher signal at all. Any accuracy gap between the two Students is then "
+    "attributable to distillation alone."
+)
+
+h("Implementation", 3)
+p(
+    "The baseline Student is trained with the same train_student() routine used for the distilled Student, "
+    "but with distill=False, for 8 epochs, batch size 32, learning rate 3e-4, AdamW, on CPU (127.6 seconds "
+    "total). All three models — Teacher, baseline Student, distilled Student — are then evaluated on "
+    "the same held-out 3,080-example test set using scikit-learn's accuracy_score and f1_score (macro and "
+    "weighted)."
+)
+add_image(f"{ASSETS}/baseline_vs_distilled_loss.png", width=5.0,
+           caption="Figure 2. Training loss: baseline student (cross-entropy only) vs. distilled student (KD + CE). Note the two loss compositions are not directly comparable in scale.")
+
+h("Results — Comparison Table", 3)
+add_table(
+    ["Model", "Accuracy", "Macro F1", "Weighted F1"],
+    [
+        ["Teacher (bert-base-uncased)", "87.56%", "0.868", "0.868"],
+        ["Student — without distillation", "83.47%", "0.836", "0.836"],
+        ["Student — with distillation", "87.44%", "0.874", "0.874"],
+    ],
+    col_widths=[3.0, 1.6, 1.4, 1.5],
+)
+
+h("Interpretation", 3)
+p(
+    "The undistilled Student, trained only on hard labels with a 37.7x smaller architecture, reaches "
+    "83.5% accuracy — a substantial (4.1-point) gap below the Teacher's 87.6%, as expected given how "
+    "much capacity was removed. Adding the Teacher's soft labels — with the architecture, data, and "
+    "epoch budget held fixed, changing only the loss function — raises the Student to 87.4% accuracy, "
+    "closing 97% of the accuracy gap between the undistilled Student and the Teacher. In this run, the "
+    "distilled Student retains 99.9% of the Teacher's accuracy (and slightly exceeds it on Macro/Weighted "
+    "F1) at a fraction of the parameter count. This is the central empirical claim of knowledge "
+    "distillation being demonstrated directly: dark knowledge in the Teacher's soft labels lets a small "
+    "model recover far more of a large model's decision surface than the same small model could learn "
+    "from hard labels alone. It is worth noting the closeness of Teacher and distilled-Student accuracy "
+    "also reflects that the Teacher itself is a modestly fine-tuned (3-epoch) model and the test set is a "
+    "few thousand examples — a couple of points either way is within normal run-to-run variance, and this "
+    "particular run should be read as “distillation closed essentially all of the accuracy gap,” not as "
+    "proof the Student's internal representation matches the Teacher's."
+)
+
+h("5.2 Task 6 — Deployment Metrics Analysis", 2)
+
+h("Design", 3)
+p(
+    "Accuracy alone does not determine deployability. Three deployment-relevant metrics are measured for "
+    "the Teacher and the distilled Student: on-disk model size, CPU inference latency, and peak process "
+    "RAM — the three resource axes that typically gate whether a model fits on an edge or mobile device."
+)
+
+h("Implementation", 3)
+bullets([
+    ["Disk size: ", True],
+    "each model's state_dict is serialized with torch.save to a temporary file and measured with os.path.getsize.",
+])
+bullets([
+    ["CPU latency: ", True],
+    "both models are moved to CPU; after a short warm-up, single-example (batch size 1) forward passes are timed with time.perf_counter over 50 runs, reporting mean ± standard deviation in milliseconds per query.",
+])
+bullets([
+    ["Peak RAM: ", True],
+    "measured per model in an isolated subprocess (via resource.getrusage(RUSAGE_SELF).ru_maxrss) rather than in the shared notebook kernel. This is a deliberate methodological choice: peak RSS is monotonically non-decreasing for the life of a process, so if both models were loaded into the same long-lived kernel, the Teacher's much larger footprint would contaminate any “peak RAM” reading taken afterward for the Student. Running each model's load-and-infer cycle in its own fresh subprocess gives a fair, isolated reading for each.",
+])
+
+h("Results — Deployment Metrics", 3)
+add_table(
+    ["Metric", "Teacher", "Student", "Reduction"],
+    [
+        ["Disk size (MB)", "417.9", "11.1", "37.7x"],
+        ["CPU latency (ms/query)", "27.76 ± 3.07", "1.18 ± 0.09", "23.5x"],
+        ["Peak RAM (MB, isolated process)", "893.8", "237.0", "3.8x"],
+    ],
+    col_widths=[3.0, 1.7, 1.7, 1.3],
+)
+
+h("Interpretation — Deployment Readiness", 3)
+p(
+    "The distilled Student is 37.7x smaller on disk, 23.5x faster per CPU query, and uses 3.8x less peak "
+    "RAM than the Teacher, while retaining 99.9% of its accuracy on the same 77-way classification task. "
+    "In this run there is essentially no accuracy trade-off to weigh against those savings — which is a "
+    "favourable outcome rather than a guarantee, since it partly reflects a lightly fine-tuned Teacher and "
+    "a modest-size test set; a production rollout should still monitor accuracy on live traffic rather "
+    "than assuming this margin holds indefinitely as the input distribution drifts."
+)
+bullets([
+    ["Size and RAM. ", True],
+    "At ~11MB on disk and ~237MB of peak RAM, the Student comfortably fits within the memory budgets of edge devices and mobile apps, where a 418MB+ BERT-base checkpoint is frequently a non-starter (app-store bundle-size limits, low-RAM Android devices, on-device model caches).",
+])
+bullets([
+    ["Latency. ", True],
+    "1.2ms/query on CPU is well within the range needed for a responsive, synchronous UI interaction (e.g. intent routing as a user types), whereas the Teacher's 27.8ms/query, multiplied across a request queue on a resource-constrained device, would noticeably degrade perceived responsiveness.",
+])
+bullets([
+    ["Practical recommendation. ", True],
+    "Deploy the distilled Student as the default path, and route low-confidence predictions (small margin between the top-2 softmax probabilities) to the Teacher or a human reviewer. This captures most of the demonstrated size/latency/RAM benefits while bounding accuracy risk to only the genuinely ambiguous cases — exactly the scenario dark-knowledge distillation is suited for, since the Student was trained to mimic the Teacher's confidence structure, not just its arg-max.",
+])
+bullets([
+    ["When the Student alone would not suffice. ", True],
+    "For a fully autonomous decision with no fallback path (e.g. auto-approving a refund), any residual gap to the Teacher — even a small one — may still argue for keeping the Teacher, or a human, in the loop.",
+])
+
+doc.add_page_break()
+
+# ---------------------------------------------------------------------------
+# 6. Conclusion
+# ---------------------------------------------------------------------------
+h("6. Conclusion and Key Takeaways", 1)
+bullets([
+    ["Dark knowledge transfers real signal. ", True],
+    "Distillation closed roughly 97% of the accuracy gap between an undistilled and a distilled Student sharing the same 37.7x-smaller architecture, using only a change of loss function — no additional data, parameters, or training time.",
+])
+bullets([
+    ["Vocabulary size is a first-order compression lever. ", True],
+    "A domain-trained, 10x-smaller Student tokenizer removed roughly a quarter of the Student's total parameter budget on its own, independent of encoder depth or width.",
+])
+bullets([
+    ["Sequence-classification distillation avoids the hardest alignment problem. ", True],
+    "Because the Teacher produces one probability vector per example rather than per token, Teacher/Student tokenizer mismatch only requires row-level index alignment, not token-level alignment — a substantially simpler engineering problem than seq2seq or token-classification distillation would pose.",
+])
+bullets([
+    ["The compression/latency/RAM payoff is large and the accuracy cost, in this run, is negligible. ", True],
+    "37.7x smaller on disk, 23.5x faster on CPU, 3.8x less peak RAM, for 99.9% of the Teacher's test accuracy — making the distilled Student a strong candidate for edge or mobile deployment, ideally paired with a confidence-based fallback to the Teacher for the hardest cases.",
+])
+
+# ---------------------------------------------------------------------------
+# 7. Environment & Reproducibility
+# ---------------------------------------------------------------------------
+h("7. Environment and Reproducibility", 1)
+add_table(
+    ["Item", "Value"],
+    [
+        ["Conda environment", "agn_env"],
+        ["Python version", "3.12.8"],
+        ["Key libraries", "torch, transformers, datasets, tokenizers, scikit-learn, psutil, accelerate, evaluate"],
+        ["Hardware", "Apple Silicon (M-series), MPS acceleration for Teacher fine-tuning"],
+        ["Teacher training device", "MPS"],
+        ["Student training/inference device", "CPU (by design, matching the deployment target)"],
+        ["Random seed", "42 (Python, NumPy, PyTorch)"],
+        ["Source artifact", "knowledge_distillation_assignment.ipynb (single, end-to-end executed notebook)"],
+    ],
+    col_widths=[2.4, 3.9],
+)
+p(
+    "The notebook can be re-executed top-to-bottom via jupyter nbconvert --to notebook --execute --inplace "
+    "knowledge_distillation_assignment.ipynb inside the agn_env environment. Minor variation (typically "
+    "within 1–2 accuracy points) between runs is expected due to non-deterministic operations in "
+    "MPS-accelerated training and dataloader shuffling order."
+)
+
+doc.save("/Users/reevechaitanya/Documents/2_Experimentation_n_Research/demo/Knowledge_Distillation_Report.docx")
+print("Report written.")

demo/nbconvert_run.log

@@ -0,0 +1,6 @@
+[NbConvertApp] Converting notebook knowledge_distillation_assignment.ipynb to notebook
+[IPKernelApp] WARNING | Kernel is running over TCP without encryption. All communication (including code and outputs) is sent in plain text and is susceptible to eavesdropping. Use IPC transport or launch with kernel manager-provisioned CurveZMQ keys to enable transport encryption.
+
+
+
+[NbConvertApp] Writing 206530 bytes to knowledge_distillation_assignment.ipynb