Session 1

Read this first: how to use this pack alone

You don’t need a teacher for this. Everything a coach would say is written right here. By the end you will have trained a real neural network in Python — and understood what that actually means.

• What you need: a computer with a web browser and internet, and a free Google account. That’s it. No installing anything.
• How long: about 90–120 minutes. Go at your own pace. You can stop and come back.
• How it works: you’ll read a step, copy a block of code into Google Colab, run it, look at what happens, and write your numbers in this pack.
• Write in this pack. The blanks and boxes aren’t decoration — your numbers become your evidence (and later, your resume).

Three real wins — check them off as you earn them:

• Train & evaluate a real image classifier and report its held-out accuracy.
• Tune two knobs (settings) and explain what changed and why.
• Speak the language: explain features, labels, and loss — and how data shapes behavior.

By the end you’ll be able to honestly say: “I trained a neural network in code today.”

Learn these four and you can explain any AI. We’ll use today’s example (teaching a computer to recognize handwritten digits):

Say them out loud right now: features, label, loss, training. You’ll use all four in the next hour.

Google Colab is a free website where you write and run Python — nothing to install. Do this once:

1. Go to colab.research.google.com in your browser.
2. Sign in with your Google account if it asks.
3. Click File → New notebook. A blank page with an empty grey box appears. That grey box is a cell — where code goes.
4. Click inside the cell, type print("hello AI"), then press Shift + Enter to run it. You should see hello AI appear below.

Rule one of machine learning: look at your data before you model it. We’ll use a famous set of 1,797 tiny (8×8 pixel) images of handwritten digits that comes built into Python.

from sklearn.datasets import load_digits
import matplotlib.pyplot as plt

digits = load_digits()
print("We have", len(digits.images), "images")
print("Each image is", digits.images[0].shape, "pixels")

# Look at the first 10 digits and their real labels
fig, axes = plt.subplots(1, 10, figsize=(12, 2))
for ax, image, label in zip(axes, digits.images, digits.target):
    ax.imshow(image, cmap="gray")
    ax.set_title(label)
    ax.axis("off")
plt.show()

What just happened: each image is really just 64 numbers (an 8×8 grid of brightness values from 0–16). Those 64 numbers are the features. The digit written on top is the label. That’s the whole dataset: features + labels.

Here’s the most important idea in all of machine learning. If you let the model study every example and then test it on those same examples, of course it looks perfect — it’s an open-book test on questions it memorized. So we split the data: most for studying (train), some hidden away for the real exam (test).

from sklearn.model_selection import train_test_split

X = digits.data      # features: 64 numbers per image
y = digits.target    # labels: the correct digit (0-9)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=450, random_state=42)

print("Studying with (train):", len(X_train), "images")
print("Hidden exam (test):   ", len(X_test), "images")
assert len(X_train) == 1347 and len(X_test) == 450
print("Split passed ✓")

Now we train a simple model called logistic regression. Don’t worry about the name — the two lines that matter are .fit() (study the training data) and .score() (take the hidden exam).

from sklearn.linear_model import LogisticRegression

model = LogisticRegression(max_iter=10000)
model.fit(X_train, y_train)        # study (this is TRAINING)

accuracy = model.score(X_test, y_test)   # the hidden exam
print("Held-out accuracy:", round(accuracy * 100, 1), "%")

Write your number: My logistic-regression held-out accuracy = %

That percent is the fraction of the 450 never-before-seen digits it got right. This is the only honest grade — it was measured on the hidden exam, not the study set.

A good scientist studies the failures. Let’s look at digits the model got wrong.

import numpy as np

predictions = model.predict(X_test)
wrong = np.where(predictions != y_test)[0]
print("It got", len(wrong), "wrong out of", len(y_test))

fig, axes = plt.subplots(1, 5, figsize=(11, 2))
for ax, idx in zip(axes, wrong[:5]):
    ax.imshow(X_test[idx].reshape(8, 8), cmap="gray")
    ax.set_title(f"real {y_test[idx]}, said {predictions[idx]}")
    ax.axis("off")
plt.show()

A single accuracy number hides which digits it struggles with. A confusion matrix is a report card with detail: rows are the truth, columns are what the model said. The diagonal is where it was right.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

cm = confusion_matrix(y_test, predictions)
ConfusionMatrixDisplay(cm).plot(cmap="Greens")
plt.show()

Now read it like an engineer: recall by hand

The most useful question isn’t “how accurate overall?” It’s per-class recall: of all the true 8s, what fraction did the model catch? Here is a small real example (just digits 1, 7, 8, 9):

Worked example — recall for digit 8: the model correctly caught 38 of the 45 true 8s. Recall = 38 ÷ 45 = 0.844 = 84%. The other 7 true 8s were mislabeled (six became 9s, one became a 1).

Time for the headline. A neural network is a more powerful model, loosely inspired by brain cells (“neurons”). Watch its loss (wrongness) fall as it trains — that falling curve is learning happening.

from sklearn.neural_network import MLPClassifier

nn = MLPClassifier(hidden_layer_sizes=(64,), max_iter=500, random_state=42)
nn.fit(X_train, y_train)
print("Neural net accuracy:", round(nn.score(X_test, y_test) * 100, 1), "%")

# Watch the loss curve fall = watch it learn
plt.plot(nn.loss_curve_)
plt.xlabel("training round")
plt.ylabel("loss (wrongness)")
plt.title("Watch the loss fall")
plt.show()

Write your number: My neural-network accuracy = %  —  higher or lower than logistic regression?

Stop and notice: you just trained a neural network in code. That sentence is true now in a way it wasn’t an hour ago. Write your version of it here:

Real understanding comes from breaking things on purpose. For each change below, first write your prediction, then run it, then explain what happened. Copy cell 6, change the one line shown, and re-run.

*For the last one, change nn.fit(X_train, y_train) to nn.fit(X_train[:100], y_train[:100]) — it studies only 100 images instead of 1,347.

A model can be wrong and sure of itself, or wrong and hesitant. In the real world, one is far more dangerous. Imagine a self-driving car’s vision system.

(A hint for your thinking: a hesitant model can ask for help or hand off to a human. A confident-and-wrong model just acts — and nobody double-checks it.)

Errors are normal and good — every engineer reads dozens a day. Read the last line of the error first. Here are the common ones:

Tick each one you can truly say yes to:

• I loaded 1,797 images and looked at them.
• I split the data 1347/450 and the tripwire passed.
• I trained a model and wrote down its held-out accuracy.
• I read a confusion matrix and computed recall by hand.
• I trained a neural network and watched its loss curve fall.
• I changed two knobs and can explain what happened.

This becomes part of your 4-H record book and your capstone story. Numbers are evidence — always write the numbers.

Name:    Date:

What I DID (tools, notebooks, checkpoints passed):

What I LEARNED (one surprise counts double):

MY NUMBERS (accuracies, recalls, loss behavior):

1. One stretch experiment: make a plot of accuracy vs. how many training examples you use (try 100, 300, 700, 1347). Watch accuracy climb as data grows — that’s Law #1 as a picture.
2. Choose & save your Session 3 corpus: 300+ words you love and have the right to use (song lyrics, your own writing, or public-domain text). You’ll build a language model from it.
3. Find one real-world AI-failure article and bring the link/source.

Mission complete?   Yes    Partly — what I got done: