| """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)) |
|
|
| |
| |
| |
| 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 | |
| """) |
|
|
| |
| |
| |
| 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}") |
| """) |
|
|
| |
| |
| |
| 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. |
| """) |
|
|
| |
| |
| |
| 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). |
| """) |
|
|
| |
| |
| |
| 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. |
| ''')) |
| """) |
|
|
| |
| |
| |
| 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.""") |
|
|
| |
| |
| |
| 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} |
| ''')) |
| """) |
|
|
| |
| |
| |
| 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.") |
|
|
