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