AI Office Hours

Everyone's talking about large language models, but here's the question nobody starts with: how does a machine even represent a word in the first place? A computer only understands numbers — so before any of the ChatGPT magic can happen, "king," "queen," and "dog" have to become vectors of numbers. And how you do that turns out to be the whole ballgame.

This session goes back to the idea that cracked it open: Word2Vec. It's the technique that first showed you could capture a word's meaning as a position in space — close words end up close together, and you get the famous result that king − man + woman ≈ queen. Meaning becomes geometry. Once you see this, modern LLMs stop feeling like magic and start feeling like a natural next step.
We'll walk through, intuitively:

• Why words become vectors — the core idea of embeddings, and why "similar meaning = nearby in space" is so powerful
• Continuous Bag of Words (CBOW) — predicting a word from the words around it
• Skip-gram — flipping it around: predicting the surrounding words from a single word, and why it shines on rarer words
• Why any of this matters for today's LLMs — how these early ideas grew into the token embeddings inside every model you use now

No heavy math required — this is built to be intuitive and beginner-friendly. Come with curiosity and your questions. We'll wrap with an open Q&A (~30 min) so you can ask whatever's been nagging you about how these models actually work.
Great for beginners. Bring your questions.

Ever wonder why we train regression models on mean squared error?
Most of us learned MSE as a rule to memorize: regression task → square the errors → minimize. But it's not an arbitrary choice. MSE falls straight out of probability theory — once you ask "what distribution generated this data?", the loss basically derives itself.
In this focused hour, we'll trace exactly where MSE comes from:

• How MSE emerges from a Gaussian likelihood
• What "minimizing squared error" is really doing under the hood
• Why this reframing makes the loss landscape feel principled instead of arbitrary

Come with basic ML familiarity and your questions — this is meant to be interactive, not a lecture. You'll leave seeing a loss function you already use every day in a completely different light.
One focused hour. Bring a notebook.

The first AI Office Hours runs like a class — relaxed but structured.
I'll walk through where AI actually is in 2026: what LLMs, image models, and agents really do, what they don't, and how to read past the hype. Beginners will leave with a real mental model; folks already working with these tools should pick up some sharper angles. We'll close with open Q&A.
No prerequisites. Bring a question. Online via Zoom.

Hosted by Bob (Jue) Guo — CS PhD candidate and adjunct faculty at the University at Buffalo, teaching deep learning, machine learning, and AI.

This workshop series is extremely hands on and interactive. A dedicated teaching assistant and I will answer your questions within 24 hrs.

No API keys. No per-token bills. No data leaving your machine.
Everyone has used ChatGPT. Far fewer have run a 70-billion-parameter model on hardware they control, fine-tuned it on their own data, and served it to a team. Over six weeks we build that, end to end. You leave with working code, not slides.

HOW IT WORKS
Each week has two sessions.

1. Tuesday is concepts — 90 minutes, slides and live demo, nothing to install. Come tired, watch, ask questions.
2. Thursday is the lab — 90 minutes, hands-on, you build the thing. This is the session that matters most.

The gap between them is deliberate. It gives you a day to sit with the ideas before you type.

WHAT YOU NEED
A laptop with 16 GB of RAM or more. Weeks 1, 2 and 4 run entirely on your own machine.
Weeks 3 and 5 need a GPU, and we'll walk you through spinning one up in the cloud. The free tier of Google Colab covers most of it; if you'd rather rent something faster, expect to spend under $15 for the whole course. Notebooks go out before each lab, so you're not configuring anything from scratch during class.
No hardware purchase required.

WHO THIS IS FOR
You're comfortable in a terminal and can read Python. You don't need machine learning experience — we build the concepts as we go — but you should be able to install things and debug them when they break.
If you're looking for a lecture series, this isn't it.

WHAT YOU'LL WALK AWAY WITH

• Three or more models running locally, and the judgment to choose between them
• A sizing method that tells you before downloading whether a model fits your hardware
• A serving endpoint your existing OpenAI-compatible code can hit by changing one line
• A working RAG pipeline over your own private documents
• A fine-tuned adapter trained on your own data
• An evaluation harness, so you can prove a change actually helped

SCHEDULE
All sessions 6:30 PM ET. Tuesdays 90 minutes, Thursdays 2 hours.
Week 1 — Get it running

• Tue Jan 12 · What "local" actually means, and the model landscape
• Thu Jan 14 · Three models running on your laptop. Measure latency and quality yourself, and find where "bigger is better" stops being true.

Week 2 — The memory math

• Tue Jan 19 · Quantization, the memory formula, and the KV cache everyone forgets
• Thu Jan 21 · Build a sizing worksheet: given your hardware, what runs, at what context length, at what quality.

Week 3 — Serving it properly

• Tue Jan 26 · Batching, throughput vs. latency, and an honest cost model
• Thu Jan 28 · Stand up a serving endpoint your existing code can hit by changing one line.

Week 4 — RAG on your own documents

• Tue Feb 2 · Embeddings, chunking, retrieval, and why retrieval quality caps answer quality
• Thu Feb 4 · Build a RAG pipeline over your own files. Then break it on purpose and diagnose why.

Week 5 — Fine-tuning with LoRA

• Tue Feb 9 · LoRA, QLoRA, and the harder question of when not to fine-tune at all
• Thu Feb 11 · Train an adapter on your own data. Compare before and after on held-out examples.

Week 6 — Evaluation and production

• Tue Feb 16 · Test sets, LLM-as-judge, guardrails, prompt injection, model lifecycle
• Thu Feb 18 · Build an eval harness you can run against everything from the previous five weeks.

The syllabus and course link will be shared with you once you've registered.