Clawdemy Lessons

An overview of the confidence interval lesson: how to build the interval, what sets its width, the correct interpretation, and how to read AI metrics with it.

Overview of the conditional probability lesson: what you will learn, how it fits after the multiplication rule, the prerequisites, and the math involved.

Overview of the Bayes' theorem lesson: what you will learn, prerequisites, the natural-frequencies and formula approach, and how it connects to AI.

Overview of the datasets-library lesson: what you will learn, where it fits, prerequisites, and time to load, clean, and transform real data.

What the tokenizers lesson covers: the four-stage pipeline, fast vs slow tokenizers, the three subword algorithms, and training one on a corpus.

Orientation for the common NLP tasks lesson: the shared loop, how each task maps to a head and metric, prerequisites, and what to read next.

An overview of publishing to the Hugging Face Hub: authenticate, compare the three upload routes, and learn why the model card is the real deliverable.

What this code lesson covers: the pipeline() one-liner, the three steps it hides, the Auto classes, logits, and the from_pretrained idiom.

Overview of the reasoning-models capstone: what they add over LLMs, how RL trains step-by-step thinking, and the working method that outlasts the frontier.

Overview of supervised fine-tuning: distinguishing it from task fine-tuning, when to use SFT versus prompting, chat templates, the SFTTrainer, and LoRA.

What this fine-tuning lesson covers: prerequisites, the data collator, head-swap warning, TrainingArguments, the Trainer, and evaluation discipline.

Overview of the debugging lesson: what you'll learn, where it fits, prerequisites, and time, for reading tracebacks and asking for help effectively.

A guide to what this lesson covers: why data quality dominates LLM results, the Argilla curation workflow, dataset evaluation checks, and prerequisites.

What you will learn, prerequisites, and time for building a shareable Gradio demo and publishing it on Hugging Face Spaces, no frontend code.

A guided overview of the cost function: how it scores a network's wrongness, computing it by hand, and why learning is just minimizing that one score.

An overview of the backpropagation lesson: why brute force fails, the reframe to what each neuron wants, and how wishes roll backward to give the gradient.

Overview of the neuron computation: weighted sum, bias, and squish (sigmoid or ReLU), plus what weights and biases do and how to count a network's parameters.

A neural network as one function: brief overview of the forward pass, the f(x; w, b) split, and why parameter values, not structure, drive all behavior.

Overview of the cost landscape: the gradient, the negative gradient as the downhill compass, worked one and two-knob steps, and the local minimum caveat.

Overview of the neural network synthesis lesson: the whole picture in one breath, one full training step, what was deferred, and where to go next.

What this lesson on neurons and layers covers: activations, input and output layers, hidden layers, feedforward flow, plus prerequisites and timing.

A brief on gradient descent: the update rule, learning rate tradeoffs, the training loop, stochastic gradient descent, and what backpropagation will explain.

Backpropagation as the chain rule: a brief preview with learning outcomes, prerequisites, the worked chain, and where the vanishing gradient comes from.

Overview of the opening computer vision lesson: the semantic gap, the recognition challenges, why hand-written rules fail, and the data-driven approach.

What this opening lesson covers: the flip from rules to learning from data, the supervised and unsupervised families, and why models are judged on unseen data.