« Track Overview · Warmup · Hitchhiker's · Deep Dive · Principal Deep Dive · Core Contributor · Staff Notes

Phase 30 — Hugging Face: Transformers, Pipelines, the Hub & PEFT

Answers these JD lines: "Experience with Hugging Face and LangChain for building LLM-powered applications" (JD1, verbatim), plus every posting that says "fine-tuning open-source LLMs," "LoRA/PEFT experience," "model deployment with TGI / Inference Endpoints," or "evaluate and adapt open-weight models." LangChain got its own deep dive in Phase 29; this phase is the other half of that JD sentence — the ecosystem you reach for the moment "call a proprietary API" stops being the whole answer and "pick, adapt, and serve an open model" starts being your job.

Why this phase exists

Most of this track calls models through someone else's serving layer — an API key and a converse() call. That is the right default, and it is also exactly where a Staff-level conversation stops being about prompts and starts being about the model supply chain: which open model, under which license, at which revision, tokenized how, adapted with what, quantized to fit where, served on which stack. Hugging Face is the de-facto standard answer to every one of those questions, and interviewers who put "Hugging Face" in a JD are probing for exactly this workflow fluency. Three ideas do most of the work:

1. One convention over ten thousand models. AutoTokenizer.from_pretrained(id) + AutoModelFor*.from_pretrained(id) load any supported architecture from a config file — the Auto* classes dispatch on config.json, so your code doesn't hard-code an architecture. The pipeline() abstraction goes one step further and wires tokenizer + model + task-specific pre/post-processing behind a single callable (Lab 01).
2. The Hub is a versioned artifact store, not a download site. Every model/dataset/Space repo is git-backed: commits, branches, tags, model cards with licenses, gated access, and safetensors-vs-pickle load safety. from_pretrained(..., revision=...) is a reproducibility discipline, and trust_remote_code is a supply-chain decision (Lab 03).
3. Adaptation is cheaper than you think; serving is harder than you think. PEFT/LoRA fine-tunes well under 1% of parameters and produces megabyte adapters you can merge or swap (Lab 03); QLoRA does it on a 4-bit base so a single GPU suffices. On the way out, quantization (bitsandbytes/GPTQ/AWQ) and a real serving stack (TGI's continuous batching, Inference Endpoints) decide whether your fine-tune ever meets production traffic.

One boundary, stated up front: this phase teaches the Hugging Face ecosystem and workflow — the practitioner's API surface, the Hub, and PEFT. It deliberately does not re-derive transformer internals: attention math, backprop, and building GPT from scratch are the Senior AI Engineer sibling track's territory. Here, the model is a thing you load, adapt, and serve; there, it's a thing you build. A principal engineer needs both, but they are different muscles.

Concept map

• transformers — AutoConfig/AutoTokenizer/AutoModel and from_pretrained (revisions, cache, safetensors); the pipeline() task abstraction (Lab 01); generate() + GenerationConfig (Lab 02); Trainer/TrainingArguments for fine-tuning.
• tokenizers — BPE vs WordPiece vs Unigram/SentencePiece; special tokens, padding/truncation, attention masks, offset mappings (Lab 02).
• The Hub — models/datasets/Spaces; model cards + licenses; gated models; git revisions and push_to_hub; safetensors vs pickle and trust_remote_code (Lab 03).
• datasets — Arrow-backed memory-mapping, streaming, map/filter — data that doesn't have to fit in RAM (Warmup §8).
• peft — LoRA (rank/alpha/target-modules, merge/swap), QLoRA (4-bit base + LoRA), prompt-tuning and friends (Lab 03).
• Quantization — bitsandbytes (load-time), GPTQ/AWQ (post-training, calibrated) — concepts and tradeoffs (Warmup §11).
• Serving — Text Generation Inference (continuous batching, paged KV), Inference Endpoints, and accelerate for device placement and distributed launch (Warmup §12–13).

The labs

Integrated scenario (how this shows up at work)

Your team's support assistant runs on a proprietary API. Finance wants the cost down, legal wants data in-house, and product wants the model to speak your domain's vocabulary. You shortlist open models on the Hub — checking each model card for license terms your lawyers will accept and accepting a gated model's terms where needed — and pin exact revisions so the eval you run today is the model you deploy next month. You load candidates with AutoModelForCausalLM.from_pretrained (safetensors only, no trust_remote_code without review) and screen them with a pipeline() harness (Lab 01). Your domain data goes through datasets — memory-mapped, streamed, map-tokenized once and cached. You fine-tune with QLoRA: 4-bit base, LoRA adapters on the attention projections, Trainer for the loop — a single-GPU job producing a 40 MB adapter instead of a 14 GB checkpoint (Lab 03). You push_to_hub the adapter to a private repo with a model card, tag it v1.0, and A/B it against v1.1 by swapping adapters on one shared base. For launch you merge the winning adapter, quantize with AWQ, and serve on TGI behind the same gateway the rest of this track built — continuous batching keeping GPU utilization honest while generate()'s sampling knobs (Lab 02) are now a config file you can actually explain. When someone asks why the bill dropped 8x and quality held, you can draw every box in that pipeline.

Deliverables checklist

• Lab 01 green under LAB_MODULE=solution pytest and your own lab.py (31 tests).
• Lab 02 green (30 tests); you can run the BPE merge algorithm by hand on a toy corpus and explain why temperature=0 equals greedy.
• Lab 03 green (31 tests); you can prove on paper why merged and unmerged LoRA forwards are identical.
• You can write the LoRA update W' = W + (α/r)·A·B from memory and say what r, α, and target_modules each control.
• You can explain safetensors vs pickle and when trust_remote_code=True is actually justified.
• You can sketch TGI's continuous batching and say why it beats static batching for LLM serving.

Key takeaways

• pipeline() is three functions in a trench coat — tokenize, forward, post-process — and the task determines only the third. Knowing that is what lets you drop to AutoModel when the abstraction stops fitting.
• The tokenizer is part of the model. Same weights + different tokenizer = broken model; revision-pin them together.
• generate() is a loop you can read: repetition penalty → temperature → top-k → top-p → sample, until EOS or budget. Every "the model is rambling" bug lives in one of those five stages.
• PEFT changed the economics of adaptation: megabyte adapters, one shared base, merge for latency or swap for multi-tenancy — and QLoRA moved fine-tuning onto a single GPU.
• The Hub is infrastructure, not a website: licenses, gated access, revisions, and load safety are production concerns exactly the way container registries and lockfiles are.
• The senior framing: "Hugging Face is the packaging standard for open models — the ecosystem answer to 'which model, which version, adapted how, served where' — and fluency in it is what makes open-weight strategy an engineering decision instead of a leap of faith."