Title: Final Capstone Project
Course: AIINFRA 201: Model Adaptation — Fine-Tuning & Quantization > Section: Week 16 — Capstone Project & Course Review

🎓 Final Capstone Project (100 pts)

This is it — the project that ties together everything from Weeks 1–15. You will design and partially prototype a real system that exercises the core skills of AIINFRA 201: choosing an adaptation strategy, preparing data, fine-tuning efficiently, evaluating rigorously, and quantizing/deploying for real-world constraints. You are not expected to build a production system. You are expected to make and defend real engineering decisions, and to prove at least one of them works with a running artifact.

The scenario

Choose ONE realistic scenario (or propose your own and confirm it with your instructor):

Scenario | Example use case
A. Domain support assistant | Fine-tuned small LLM that answers questions in a narrow domain (e.g., internal IT helpdesk, a hobbyist community's FAQ)
B. Structured-output extractor | A model adapted to reliably turn messy text (emails, tickets, notes) into a fixed JSON schema
C. Style/tone adapter | A model fine-tuned to rewrite text in a specific voice or format for a business use case
D. Edge-deployed classifier or assistant | A quantized model sized to run on constrained hardware (laptop CPU, small VM, edge device)

Requirements

1. Problem framing. State the task, the users, and success criteria. Justify why fine-tuning and/or quantization is the right tool here rather than prompting alone or RAG alone (reference Week 1–3 concepts).
2. Data plan. Describe your dataset: source, size, format, cleaning/labeling steps, and train/eval split. Include a data quality or bias check (Weeks 4–6).
3. Adaptation method. Specify and justify your fine-tuning approach (e.g., LoRA or QLoRA), base model choice, and key hyperparameters (Weeks 7–9).
4. Evaluation plan. Define at least 3 evaluation criteria/metrics and show a before/after (base vs. adapted model) comparison on a small eval set (Weeks 10–12).
5. Quantization & deployment plan. Specify a quantization approach (e.g., GGUF/4-bit, bitsandbytes, etc.), the precision/performance trade-off you're making, and how the model would be served (Weeks 13–15).
6. Design document. A written document (1,500–2,500 words or equivalent) covering items 1–5 above, explicitly mapping each decision back to the course skill/week it draws on.
7. Diagram. One diagram showing your system end-to-end: data flow, training/adaptation step, evaluation step, and deployment/serving step. Any tool is fine (draw.io, Excalidraw, Mermaid, even a clearly labeled hand drawing photographed) as long as it's legible and exported as an image or PDF.
8. Working prototype artifact. Using the course's free/low-cost toolchain (e.g., Hugging Face Transformers/PEFT, a free-tier Colab/notebook GPU, bitsandbytes, llama.cpp/GGUF, or similar), produce ONE working artifact that demonstrates a real piece of your pipeline running — for example: a fine-tuning run with logged loss curves, a working inference script against your adapted model, or a quantized model file with a benchmark script. It does not need to be the full system — it needs to run and produce real output you can show.

Deliverables

- [ ] Design document (PDF or shared doc link)
- [ ] System diagram (image or PDF, embedded in or attached to the design document)
- [ ] Prototype artifact: code/notebook + a short README explaining how to run it and what output it produced (screenshots or logs of actual output required)
- [ ] A brief note (3–5 sentences) on what you'd need to do to take this from prototype to production

Submit all files together as an upload, or paste links in the text-entry box if hosted elsewhere (e.g., a notebook link). Grading: Scored out of 100 points using the Capstone / Project Rubric. This assignment maps to all five course outcomes (CLO1–CLO5).