Assignment & Project Guide: Day-by-Day Assignments

Beginner-friendly tasks, three-tier hints, fill-in READMEs and full solutions for Days 2–15 and the GenAI Project Ladder.

How this part works with the book

• Page references. Where this part says “Book pages 65, 84” it means pages of Parts I–III of this volume.
• It replaces the old Assignment Companion. The standard format, acceptance criteria (“You are done when…”), dataset sheet, GitHub layout, rubric and Break-it table now live once, in the day pages and in the end-matter (GitHub Submission System p. 379, Self-Rubric p. 380, Deliberate Debugging p. 382).
• Glossary. Wherever a page says “see the glossary”, use the book’s Glossary (p. 325) plus the extra terms below.
• Solutions. The Solutions Appendix (p. 384) holds runnable versions. Where it differs from a worked solution inside a day chapter (for example the Days 7–8 Telco imputer fix), prefer the appendix.

Extra glossary terms (not in the book’s Glossary)

How this guide works

Every day has two levels. Do Level 1 first. Only do Level 2 if you have time and energy.

You do NOT need Level 2 to complete the course. A finished Level 1 beats an unfinished Level 2 every time. Anything the book marks as required is in Level 1, never hidden in Level 2.

Each day is laid out the same way

1. Goal in plain words - what you are doing and why
2. Words you need - short definitions, no jargon
3. Level 1 - Must do - small numbered steps
4. You are done when… - a clear finish line (the acceptance checklist)
5. If you get stuck - the most common problems and their fixes 6. Hints - three tiers, open one at a time
6. Fill-in README - sentences with blanks to complete
7. Level 2 - Expert Challenges - optional extras
8. Solutions - complete code for every day in the appendix at the end

How to use Hints and Solutions

Never copy a solution. If you looked at it, close it and rewrite it from memory. That is where the learning happens.

How much to trust the solution code

Each solution carries the status the source guide gave it. TESTED means it was run on the exact generated data from the book. VERIFY LOCALLY means it needs an external download (Titanic, fraud, churn, MNIST, a sentence-transformers model), so run it yourself and expect your numbers to differ a little. Where this guide added a small starter that the source did not contain, it is marked ADDED STARTER (not run).

The golden rules for beginners

• Type the code yourself. Do not copy-paste. Typing teaches you.
• Run small pieces. Run one cell at a time and look at the output.
• Print shapes and heads. print(x.shape) and df.head() solve half of all bugs.
• Stuck for 15 minutes? Take a break, then read the error message from the bottom line up.
• One day = one folder = one README. Small and finished is the goal.
• Test set = once. Tune with validation or cross-validation; touch the test set at the very end.

Setup checklist (do once)

□ Install Python 3.10 or newer □ Run: pip install numpy pandas matplotlib scikit-learn jupyter torch torchvision seaborn □ Days 7–8 embeddings: pip install sentence-transformers (Day 13 optional BERT: pip install transformers ) □ Open a notebook: jupyter notebook (or use VS Code) □ Create a GitHub account and an empty repo called ml-dl-fundamentals □ Create one folder per day, e.g. Day-01-NumPy-Pandas (full list in the GitHub section)

Git in 3 commands (do this at the end of every day)

git add .
git commit -m "Finish Days 2–3"
git push

The 3 passes (a simple work rhythm)

Tidy checklist (use for every day)

□ Notebook has a title and short headings □ Kernel → Restart and Run All works with no red errors □ Every plot has a title, axis labels and (if needed) a legend □ README has a results table and at least 3 sentences of insight □ Big data files are NOT uploaded to GitHub

Datasets - one source of truth

Never use two names for one file. The Telco data downloads as WA_Fn-UseC_-Telco-Customer-Churn.csv but the book code reads telco.csv: rename the file or change the path, and note your choice in the README.

External CSVs are inputs, not deliverables: do not commit them. MNIST downloads into data/; keep data/ in .gitignore.

Difficulty: Beginner | Book pages: 65, 84; recipe 89-91

Goal in plain words

Learn to do fast math on many numbers at once (NumPy) and to clean a messy table (Pandas). Every later day uses these tools.

Words you need

Array, shape, vectorization, DataFrame, NaN, encoding (see the glossary). Cosine similarity = a score from -1 to 1 saying how similar two lists of numbers are (1 = same direction). GroupBy = split a table into groups and summarize each one.

Level 1 - Must do

Assignment A - Cosine similarity (no loops)

1. Write cosine_sim_matrix(A, B) using row normalization: A / np.linalg.norm(A, axis=1, keepdims=True). The function itself must contain no Python loop.
2. Test by hand: a=[1,0], b=[1,1] should give about 0.707.
3. Make two random matrices: A = np.random.rand(4, 8) and B = np.random.rand(5, 8).
4. Compute A_norm @ B_norm.T and check the shape is (4, 5).
5. Optional: write a slow loop version in a separate cell, only to prove the fast one is correct with np.allclose.

Assignment B - Titanic cleaning (use the book's order)

1. Load titanic.csv and look: df.head(), df.shape, df.info(), df.isna().sum() .
2. Fill missing Age with the median and missing Embarked with the most common value.
3. Drop Cabin, Ticket, Name, PassengerId. Write a one-line reason for each.
4. Turn Sex into numbers (male=0, female=1). One-hot encode Embarked with pd.get_dummies(..., drop_first=True).
5. Check there are zero missing values, then save with df.to_csv("titanic_clean.csv", index=False).
6. Use groupby on Sex and on Pclass: who survived more, women or men? Which class?

You are done when…

□ cosine_sim_matrix(A, B) returns shape (n, m) for A (n, d) and B (m, d); the function has no loop □ Every cosine value is between -1 and 1, and cosine_sim_matrix(A, A) is about 1 on the diagonal □ np.allclose between the fast and loop versions is True □ titanic_clean.csv has zero missing values and only numeric columns □ Each dropped column has a one-line reason □ README lists 3 things you found in the data

If you get stuck

Hints

• Hint 1: Think in rows. Normalize each row first; after normalization, cosine becomes a dot product.
• Hint 2: Use np.linalg.norm with axis=1 and keepdims=True; use pd.get_dummies for Embarked.
• Hint 3: A_norm @ B_norm.T gives every pair at once; df.groupby("Sex")["Survived"].mean() answers “who survived more?”

Fill-in README

I cleaned the Titanic data by dropping __ columns and filling missing with the and with the . Women survived at about % and men at about %. First class passengers survived than third class. My cosine similarity matrix has shape and my function uses __ loops.

Level 2 - Expert Challenges (optional)

1. Loop vs vectorized: compare against a deliberately slow nested loop with np.allclose and time both.
2. Zero-vector safety: handle an all-zeros row without dividing by zero.
3. Plot the similarity matrix with plt.imshow and a colorbar.
4. Chart the story: survival by sex, survival by class, age histogram.
5. Safety net: add assert df.isna().sum().sum() == 0 so the notebook fails loudly.

Full code: see Solution - Days 2–3 in the Solutions Appendix. Try Level 1 and the hints first.

Difficulty: Intermediate | Book pages: 103; recipe 112

Goal in plain words

Teach a computer to draw the best straight line through points by making small corrections again and again. That process is gradient descent. Picture a hill in fog: the hill height is the loss, your step size is the learning rate.

Words you need

Loss (MSE), learning rate, epoch, gradient descent (see the glossary). dw / db = how much the loss changes if you nudge w or b a little.

Level 1 - Must do

1. Generate the book's data: np.random.seed(42), X = 2 * np.random.rand(100, 1), y = 4 + 3 * X + np.random.randn(100, 1).
2. Start with w = 0.0, b = 0.0, lr = 0.1, epochs = 1000.
3. In a loop, do five things: predict (w * X + b), error (y_pred - y), loss (mean of error squared), gradients dw and db, then update w -= lr * dw, b -= lr * db.
4. Store the loss after every epoch in a list.
5. Plot the loss curve (it should fall and flatten) and the data points with your fitted line.
6. Fit LinearRegression() from scikit-learn and compare its w and b with yours in a small table.

You are done when…

□ Loss decreases clearly, then flattens □ w is near 3 and b near 4 (the book run gives about 2.77 and 4.21, because noise nudges the answer) □ Scratch w and b are close to scikit-learn's □ The loop uses NumPy only; the loss curve and fitted line are saved □ README explains dw and db in plain words

If you get stuck

Hints

• Hint 1: Predict first: y_pred = w * X + b. Then compute the error and the MSE.
• Hint 2: For dw the error is multiplied by X; db uses the error without X. Both start with (2/n) * sum(...).
• Hint 3: Update against the slope: w -= lr * dw and b -= lr * db. In sklearn, model.coef_[0][0] is w and model.intercept_[0] is b.

Fill-in README

My gradient descent found w = __ and b = (true values 3 and 4). scikit-learn found w = and b = . `dw` tells me and `db` tells me . The loss curve . When I made the learning rate too large, __.

Level 2 - Expert Challenges (optional)

1. Learning-rate lab: run lr = 0.001, 0.01, 0.1, 0.5, 1.5 and plot all loss curves; label “too slow”, “good”, “explodes”.
2. Wrap everything into fit(X, y, lr, epochs) that returns w, b, losses.
3. Many features: rewrite with y_pred = X @ w + b for 3 input columns.
4. Check the math: confirm your gradient against (L(w+e) - L(w-e)) / (2e).

Full code: see Solution - Day 4 in the Solutions Appendix. Try Level 1 and the hints first.

Difficulty: Intermediate | Book pages: 126-129

Goal in plain words

See with your own eyes how a model can be too simple, just right or too wild, and learn the tools that keep it under control. Overfitting is the student who memorizes past exam answers and fails a new exam.

Words you need

*Overfitting, underfitting, train/validation, Ridge (L2), Lasso (L1), cross-validation, data leakage (see the glossary). Polynomial degree* = how curvy the model is allowed to be.

Level 1 - Must do

1. Generate the book's 60-point cubic data: np.random.seed(0), X = np.sort(np.random.rand(60,1)*6-3, axis=0), y = (0.5*X 3 - X 2 + 2*X + np.random.randn(60,1)*3).ravel().
2. Split exactly: train_test_split(X, y, test_size=0.3, random_state=1).
3. For every degree 1 to 15 fit make_pipeline(PolynomialFeatures(d), StandardScaler(), LinearRegression()) and record train and validation MSE.
4. Plot both errors against degree. Validation should show a minimum around degree 3 and rise again. Name the underfit and overfit zones.

Required: regularization at degree 15

1. Compare plain LinearRegression(), Ridge(alpha=1) and Lasso(alpha=0.1, max_iter=50000) on validation MSE.

Required: 5-fold cross-validation

1. Run cross_val_score(..., cv=5, scoring="neg_mean_squared_error") for all four: Deg3 Linear, Deg15 Linear, Deg15 Ridge(alpha=1), Deg15 Lasso(alpha=0.1, max_iter=50000).
2. Flip the sign (multiply by -1) and report mean and standard deviation for all four in a 4-row table.

You are done when…

□ Degrees 1-15 are all evaluated; train error generally falls while validation error is U-shaped □ Underfitting and overfitting are explicitly identified □ Ridge and Lasso are both in the degree-15 comparison; the CV table has all four models □ No scaling is fitted on the full dataset before splitting (keep it inside the pipeline) □ README contains 3-4 lines of conclusions

If you get stuck

Hints

• Hint 1: Loop over range(1, 16) and keep two error lists.
• Hint 2: Build make_pipeline(PolynomialFeatures(d), StandardScaler(), reg); best degree is np.argmin(val_err) + 1.
• Hint 3: Loop over the four CV models; sklearn gives negative scores, so put a minus sign in front.

Fill-in README

Training error kept going __ as degree increased, but validation error went down until degree and then went . This shows . At degree 15, (Ridge/Lasso) did than plain Linear because regularization . In 5-fold CV the best model was with mean error (std __).

Level 2 - Expert Challenges (optional)

1. Shade “Underfit / Good / Overfit” zones with a dashed line at the best degree.
2. Draw the fitted curves for degrees 1, 3 and 15 over the data.
3. Try Ridge alpha = 0.01, 1, 100 and describe what happens.
4. Leakage demo: scale on ALL data vs train only and document the difference.
5. Learning curve: plot error against training set size.

Full code: see Solution - Day 5 in the Solutions Appendix. Try Level 1 and the hints first.

Difficulty: Intermediate | Book pages: 147

Goal in plain words

Learn why “99% accuracy” can be a useless score, and how to judge a model when one class is very rare (fraud). Fire alarm picture: high recall = it catches almost every fire; high precision = when it rings, there really is a fire.

Words you need

Imbalanced data, precision, recall, F1, ROC-AUC, confusion matrix, stratify (see the glossary). Random Forest = many trees voting (less wobbly). *Gradient Boosting* = trees added one by one, each fixing the last one's errors.

Level 1 - Must do

1. Load creditcard.csv (target Class) and print the fraud ratio: about 0.17% (492 of 284,807).
2. Split with train_test_split(..., test_size=0.2, stratify=y, random_state=42).
3. Fit StandardScaler on X_train[["Amount","Time"]] only, then transform train and test.
4. Train Logistic Regression (class_weight="balanced"), Random Forest ( class_weight="balanced") and Gradient Boosting.
5. For each model print the confusion matrix and compute precision, recall, F1 and ROC-AUC (AUC needs predict_proba(X_test)[:, 1]).
6. Put the 3 models x 4 metrics into one DataFrame.
7. Answer in the README: best recall, best precision, and which model you would give a bank (3 lines).

You are done when…

□ The split uses stratify=y and the scaler is fitted on train only □ You have a 3-row x 4-metric table and one confusion matrix per model □ You can explain why accuracy alone would be misleading (it is not the headline metric) □ README answers best recall, best precision and the bank choice

If you get stuck

Hints

• Hint 1: Fraud is rare, so preserve the class ratio when splitting.
• Hint 2: Probabilities go to ROC-AUC; predicted labels go to the confusion matrix and precision/recall/F1.
• Hint 3: Loop over a dictionary of the three models: fit, predict, predict_proba(...)[:, 1], then collect the four scores.

Fill-in README

Only __% of transactions are fraud, so a model that always says “not fraud” gets % accuracy but % recall. My best recall was (model: ). My best precision was (model: ). For a bank I would choose because missing fraud costs while a false alarm only __.

Level 2 - Expert Challenges (optional)

1. Dumb baseline: show “always predict not-fraud” first (great accuracy, zero recall).
2. Draw ROC and precision-recall curves for all three models.
3. Threshold tuning: try 0.3 / 0.5 / 0.7 and show the precision-recall trade-off.
4. SMOTE on the TRAIN set only, then compare.
5. Show the top 10 Random Forest feature importances.

Full code: see Solution - Day 6 in the Solutions Appendix. Try Level 1 and the hints first.

Difficulty: Intermediate | Book pages: 155-176

Goal in plain words

Do four small checkpoints so every Days 7–8 idea is used once (k-NN, k-Means, PCA, embeddings), then build your first complete machine learning project: predict which phone customers will leave (churn) and explain why. A Pipeline is a conveyor belt: clean, scale, encode, predict, always in the same order, always learning only from training data.

Words you need

*k-NN, k-Means, elbow, PCA, embedding, cosine similarity, Pipeline, ColumnTransformer, stratified CV, feature importance, churn (see the glossary). Inertia* = how tight the k-Means clusters are.

Level 1 - Must do

Parts A-B - Distance + k-NN checkpoint

1. By hand, for P1=(25, 6) and P2=(30, 8), compute Euclidean, Manhattan and cosine values.
2. Make or reuse a tiny labeled matrix; run StandardScaler then KNeighborsClassifier(n_neighbors=5).
3. Write one sentence on why scaling changes neighbor distances.

Part C - k-Means checkpoint

1. Take the Telco numeric columns tenure, MonthlyCharges, TotalCharges (convert TotalCharges first) and scale them.
2. Run KMeans for k = 1..10 with n_init=10, random_state=42; save an elbow plot ( inertia_ vs k).
3. Choose a candidate k and record the cluster labels and centers.

Part D - PCA checkpoint

1. Use the same scaled matrix; run PCA(n_components=2).
2. Record X2.shape and explained_variance_ratio_.
3. Write one sentence on what the two components mean at a high level (they are not original columns).

Part E - embeddings checkpoint

1. Embed “How to reset my password”, “Best pizza recipes”, “Change account login credentials” with all-MiniLM-L6-v2.
2. Embed the query “I forgot my password”, compute cosine similarity (your Days 2–3 function), find the top match.
3. Record the embedding shape and the winning sentence.

Part F - Mini Project 1: Telco Customer Churn

1. Load telco.csv; print shape, info() and the churn ratio (about 27%).
2. Convert TotalCharges with pd.to_numeric(..., errors="coerce"); fill the blanks inside the pipeline (no leakage).
3. Drop customerID; map Churn Yes/No to 1/0.
4. Split 80/20 with stratify=y, random_state=42.
5. Build a ColumnTransformer: scale the number columns, one-hot encode the text columns.
6. Train Logistic Regression and Random Forest, each inside a Pipeline.
7. Run 5-fold stratified CV; compare recall, precision, F1 and ROC-AUC. Pick the stronger model.
8. Evaluate that model on the test set once.
9. Show the top features that drive churn (Random Forest importances) as a bar chart.
10. Write the README: problem, dataset, approach, results, insights, how to run.

You are done when…

□ Parts A-B show distance methods need scaling; Part C has an elbow plot for k = 1..10 □ Part D records X2.shape and explained_variance_ratio_; Part E reproduces the semantic-search idea □ Telco uses Pipeline + ColumnTransformer and compares Logistic Regression vs Random Forest with 5-fold stratified CV □ Telco reports recall, precision, F1, ROC-AUC; the test set is used once after model selection □ Feature-importance chart is included and the README explains in plain words why customers leave

If you get stuck

Hints

• Hint 1: For k-NN and k-Means, standardize before distances or cluster assignment.
• Hint 2: The elbow is inertia_ versus k; PCA exposes explained_variance_ratio_; embeddings reuse your Days 2–3 cosine.
• Hint 3: For Telco keep every preprocessing step inside ColumnTransformer / Pipeline and do not look at test performance until the end.

Fill-in README

Checkpoints: scaling matters for k-NN because __. My k-Means elbow suggests k = . PCA kept of the variance in 2 components. The embedding winner was . Telco: customers, % churn. Best model with ROC-AUC and recall on the test set. Customers with contracts, tenure and internet are most likely to leave. Recommendation: __.

Level 2 - Expert Challenges (optional)

1. EDA first: churn by contract type, tenure histogram by churn, monthly charges by churn.
2. Add Gradient Boosting and report mean +/- std from CV.
3. GridSearchCV on the Random Forest.
4. Save the pipeline with joblib and write a predict_one(customer) example.
5. Business value: estimate the money saved by contacting the riskiest 20%.

Full code: see Solution - Days 7–8 in the Solutions Appendix. Try Level 1 and the hints first.

Difficulty: Intermediate | Book pages: 201-210

Goal in plain words

Build a tiny neural network using only NumPy so nothing is hidden. After this, PyTorch will feel like a shortcut, not magic. Forward pass = make a guess. Loss = how wrong. Backprop = who is to blame. Update = fix the weights a little.

Words you need

*Neuron, activation (ReLU, sigmoid, tanh), forward pass, loss (BCE), backpropagation, hidden layer, He initialization, gradient check* (see the glossary).

Level 1 - Must do

1. Make the Moons data: make_moons(n_samples=1000, noise=0.2, random_state=42), split 80/20 (random_state=42), reshape labels to (n, 1).
2. Write relu, relu_grad, sigmoid and bce (with a tiny epsilon so log(0) never happens).
3. Initialize W1 with He initialization (randn * sqrt(2/n_in)), biases at zero, W2 with the book's small-random pattern.
4. Loop: forward (layer 1, ReLU, layer 2, sigmoid), loss, backward (dW2, db2, dW1, db1), update (W -= lr * dW).
5. Record train and test loss and accuracy; plot the loss curve.
6. Gradient check before updating weights: compare the analytic dW1[0,0] with (L(w+eps) - L(w-eps)) / (2*eps).
7. Required experiments: hidden size 2, 4, 16, 64; learning rate 0.001, 0.01, 0.1, 1.0; ReLU vs tanh. Record each in a table.
8. Remove the hidden layer and report the accuracy (the linear/logistic baseline).
9. Write observations for every experiment in the README (not just a screenshot of numbers).

You are done when…

□ Moons uses 1,000 samples and noise=0.2; loss decreases over training □ Numerical and analytic gradients agree closely (about 6 decimals in the book example) □ Hidden size, learning rate and tanh/ReLU experiments are recorded, with a README observation for each □ Without the hidden layer, accuracy drops to about 85% as the book explains □ You can explain forward and backward in your own words

If you get stuck

Hints

• Hint 1: Write the shapes on paper first: X (n,2), W1 (2,16), hidden (n,16), W2 (16,1), output (n,1).
• Hint 2: Start backward at dZ2 = A2 - y, then walk back one layer at a time; ReLU passes gradient only where the input was positive.
• Hint 3: For the gradient check, nudge W1[0,0] by +eps and -eps, recompute the loss both times, and compare with the analytic value.

Fill-in README

My network has __ inputs, hidden neurons and output. It reached % test accuracy. The loss went from to . Gradient check: analytic , numeric . Backpropagation means . Without a hidden layer I got about % because the boundary can only be a . Bigger hidden size ; a learning rate of 1.0 ; tanh vs ReLU __.

Level 2 - Expert Challenges (optional)

1. Plot the decision boundary the network learned.
2. Wrap everything in a NeuralNet class with .fit() and .predict().
3. Add a second hidden layer and generalize backprop.
4. Keep a debug journal: every bug and how you fixed it.

Full code: see Solution - Days 9–10 in the Solutions Appendix. Try Level 1 and the hints first.

Difficulty: Intermediate | Book pages: 212-233

Goal in plain words

Redo the Days 9–10 network with PyTorch, which computes gradients for you, then compare six optimizer runs and save your model.

Words you need

*Tensor, Dataset, DataLoader, nn.Module, autograd, optimizer (SGD, Adam), batch, state_dict* (see the glossary). The 5-line step to memorize: zero_grad(), forward, loss, backward(), step().

Level 1 - Must do

1. Make 2,000 Moons samples (noise=0.25), 80/20 split; features float32, labels float32 with shape (B, 1).
2. Wrap in TensorDataset + DataLoader: train batch_size=32, shuffle=True; validation batch_size=256, shuffle=False.
3. Model: nn.Sequential(nn.Linear(2,16), nn.ReLU(), nn.Linear(16,1)); loss: nn.BCEWithLogitsLoss().
4. Training loop in the book order: zero_grad → forward → loss → backward → step, with model.train().
5. Validation with model.eval() and torch.no_grad().

Required: the six-run optimizer experiment

1. Run all 6 combinations: SGD and Adam, each with learning rate 0.1, 0.01, 0.001 (fresh model per run).
2. Record train loss and validation loss by epoch, plus final validation accuracy, for every run.
3. Plot all six runs together; fill the 6-row table (optimizer, LR, final train loss, final val loss, val acc).
4. Explain in plain English: speed of convergence, sensitivity to learning rate, any instability.
5. Save the selected model: torch.save(model.state_dict(), "model.pt").

You are done when…

□ All 6 runs are present (SGD x 3 rates, Adam x 3 rates) with train and validation loss logged □ All six curves are plotted together □ model.train() / eval() and torch.no_grad() are used in the right places □ state_dict is saved □ README explains what changed with optimizer and learning rate

If you get stuck

Hints

• Hint 1: Follow the order: Tensor → Dataset → DataLoader → Model → Loss → Optimizer → Training loop → Validation.
• Hint 2: BCEWithLogitsLoss already contains the sigmoid, so the model's last layer outputs raw logits.
• Hint 3: Use a fresh model per combination (reset the seed) so the six runs compare fairly.

Fill-in README

PyTorch handles ___ automatically with `loss.backward()`. `zerograd() is needed because ____. model.eval()` is used during validation because __. SGD was sensitive to learning rate than Adam; the most stable run was . My saved weights are in __.

Level 2 - Expert Challenges (optional)

1. Count parameters: sum(p.numel() for p in model.parameters()).
2. Early stopping that restores the best state.
3. Run on CUDA when available.
4. Rewrite the model as class Net(nn.Module).

Full code: see Solution - Day 11 in the Solutions Appendix. Try Level 1 and the hints first.

Note: the book's example code (p. 228) runs Adam at 0.0001, 0.001 and 0.01, while its assignment spec (p. 234) asks for 0.1, 0.01 and 0.001 for both optimizers. This guide follows the spec; if your results differ from p. 228, that is why.

Difficulty: Intermediate | Book pages: 235-252

Goal in plain words

Teach a computer to read handwritten digits with two kinds of networks and find out which is better. An MLP sees one long list of pixels; a CNN scans small patches like a magnifying glass, so it understands shapes.

Words you need

MLP, CNN, dropout, early stopping, batch, epoch, confusion matrix, logits (see the glossary). Weight sharing = the same small filter is reused everywhere in the image.

Level 1 - Must do

1. Load MNIST with torchvision and normalize (mean 0.1307, std 0.3081).
2. Split the 60k training set into 55k train / 5k validation with manual_seed(42); keep the 10k test set untouched.
3. MLP: Flatten → 784→256 → ReLU → Dropout(0.3) → 256→128 → ReLU → Dropout(0.3) → 128→10.
4. Small CNN: Conv(1→16, k3, p1) → ReLU → MaxPool(2) → Conv(16→32, k3, p1) → ReLU → MaxPool(2) → Flatten(1568) → Linear(128) → ReLU → Dropout → Linear(10).
5. Train both with CrossEntropyLoss and the 5-line step; track train/validation loss and validation accuracy each epoch.
6. Use early stopping and restore the best weights; then test both once on the test set.

Required: comparison and error analysis

1. Report parameters, validation accuracy, test accuracy and epochs stopped for MLP and CNN.
2. Save the train/validation loss curves for both models, and the CNN test confusion matrix.
3. Display and analyze at least 5 wrong predictions (the book shows 8).
4. Write why the CNN and MLP behave differently: spatial structure + weight sharing vs flattening.

You are done when…

□ Split is exactly 55k / 5k / 10k; dropout is in both the MLP and the CNN classifier □ Early stopping restores the best weights; the test set is used only after training □ CNN confusion matrix is saved; at least 5 mistakes are shown □ MLP is around 97-98%, CNN around 99%+; both are in the README table □ README explains spatial structure / shared filters as the reason for the difference

If you get stuck

Hints

• Hint 1: The MLP starts with nn.Flatten() because the image must become 784 features.
• Hint 2: Two padded 3x3 conv/pool blocks make 28 → 14 → 7, so flatten = 32 7 7 = 1568.
• Hint 3: Use test_loader only after training and validation decisions are complete; never tune on test.

Fill-in README

Split: train __ / val / test . MLP: parameters, test accuracy . CNN: parameters, test accuracy . The CNN performed because it keeps the structure of the image. Dropout helps by . The digits most often confused were and __.

Level 2 - Expert Challenges (optional)

1. Visualize the first-layer CNN filters.
2. Small data augmentation (random rotations): does accuracy improve?
3. Add BatchNorm and compare.
4. Demo cell: load a digit you draw yourself and predict it.

Full code: see Solution - Day 12 in the Solutions Appendix. Try Level 1 and the hints first.

Difficulty: Advanced | Book pages: 266-284

Goal in plain words

Understand the idea behind ChatGPT, Claude and other language models: every word looks at the other words and decides which are important. Library picture: your Query is what you are looking for, each book's Key is its label, the Value is the content inside.

Words you need

*Attention, Q/K/V, softmax, causal mask, multi-head, positional encoding, residual, LayerNorm (see the glossary). Formula: Attention = softmax( Q × K-transpose / sqrt(d_k) ) × V*.

Level 1 - Must do

1. Write a SelfAttention module with three nn.Linear(d_model, d_k, bias=False) layers for Q, K, V.
2. In forward: scores = Q @ K.transpose(-2, -1) / sqrt(d_k), row-wise softmax (dim=-1), return weights @ V and the weights.
3. Test with x = torch.randn(1, 6, 16) (1 sentence, 6 words, 16 numbers each); d_model = d_k = 16.
4. Check output shape (1, 6, 16), weights shape (1, 6, 6), and that every row of the weights sums to about 1.
5. Save a heatmap with the six labels The cat sat on the mat.

Required: causal-mask check

1. Build mask = torch.tril(torch.ones(T, T)).unsqueeze(0) and run attn(x, mask=mask).
2. Confirm everything above the diagonal (future tokens) is exactly zero; record it in the README.

Required: Transformer block explanation

1. Draw the block: Multi-Head Attention → Add/Residual → LayerNorm → FFN → Add/Residual → LayerNorm.
2. Label the key tensor shapes; explain Q, K and V in your own words (do not copy the book).

You are done when…

□ Q, K, V are each (B, T, d_k); QK^T is (B, T, T); rows of the softmax weights sum to about 1 □ Causal mask makes all future-token weights zero □ Heatmap is saved and analyzed in 5 lines; the Transformer block diagram is included □ README explains Q/K/V in your own words

If you get stuck

Hints

• Hint 1: Write the shape after every major line: X, Q/K/V, scores, weights, out.
• Hint 2: The formula is exactly softmax(QK^T / sqrt(d_k)) V.
• Hint 3: The causal mask goes on the scores before softmax; -inf becomes zero probability after softmax.

Fill-in README

Attention lets each word __. Q is , K is , V is _. We divide by sqrt(dk) because __. Each row of the attention matrix sums to because of . With the causal mask the largest future weight is . Multi-head attention helps because __.

Level 2 - Expert Challenges (optional)

1. Load pretrained BERT and plot real attention for a sentence; write 4-5 lines on what “it” attends to.
2. Implement 4-head multi-head attention and concatenate.
3. Repeat the small numeric example from book p. 265 with a calculator.
4. Build the full Transformer block at the concept level shown in the book.

Full code: see Solution - Day 13 in the Solutions Appendix. Try Level 1 and the hints first.

Difficulty: Intermediate | Book pages: 289-292

Goal in plain words

Rebuild one model by yourself from a blank file, explain it clearly, make it reproducible and publish it. This is your portfolio piece. The 15-day story: DATA → MODEL → LOSS → OPTIMIZE → EVALUATE → fix overfitting → repeat.

Words you need

Capstone, seed, reproducible, requirements.txt, .gitignore, error analysis (see the glossary). Feynman test = explain it so simply that a friend with no ML background can follow.

Choose your path (pick exactly one)

The book says: “Recommended for your GenAI goal: C or D. If short on time: C.” If unsure, pick C.

Level 1 - Must do

Step 1 - Rebuild from a blank file (about 2 hours)

1. Close all notes and videos and start from a blank file.
2. Write the skeleton in comments first: imports/seed/device → data → model → loss/optimizer → train/validation → test → plots → save model.
3. Fill in each part yourself. Stuck for 10 minutes? Look up only the one function you need.
4. Keep a list called “Things I had to look up” - it is honest and valuable.

Step 2 - Get results

1. Final test result.
2. Loss curve image and confusion matrix image (when they fit your model) saved to results/.

Step 3 - Explain it in 6 short parts (3 to 6 simple sentences each)

Step 4 - Tidy the code □ Meaningful names (train_loader, not dl1) and a short docstring on each function □ Seeds set, relative paths only; Restart and Run All works □ requirements.txt created (torch, numpy, matplotlib) □ .gitignore includes data/ , *.pt, __pycache__/, .ipynb_checkpoints/

Step 5 - README (use the template in the extras section) Problem, dataset, model/approach, training setup, results table + 2 images, failure cases, what I learned, things I had to look up, how to run, future improvements.

Step 6 - Publish □ Push to GitHub with all 10 day folders □ Update the root README table (Day, Topic, What I built, Key result)

You are done when…

□ Rebuild started from a blank file; seed set; results reproducible; test set not used for tuning □ README has results, plots, failure cases, run instructions and the six-part explanation □ Code has no absolute paths; repository contains all 10 day folders and is on GitHub □ You told someone about it (post, friend or blog)

If you get stuck

Hints

• Hint 1: Start with the skeleton and fill one section at a time.
• Hint 2: Use the exact model/data pattern from the book day you chose (Day 4, 6, 8 or 9).
• Hint 3: Explain every part in plain language; the Feynman test is required by the book.

Fill-in README

This project teaches a computer to __ because . The input is with shape ; the output is . I used loss because it . I trained with , learning rate , batch size , for epochs. The model got accuracy and struggled with . Things I had to look up: __.

Level 2 - Expert Challenges (optional)

1. Short LinkedIn/blog post following the book template.
2. Add one more model or a hyperparameter comparison.
3. A small ablation that stays within the book's concepts.
4. CNN path: filter visualization or data augmentation.

Skeleton and checkpoints: see Solution - Days 14–15 in the Solutions Appendix.