ML Fundamentals

Learning Goals 5 min

Before we use ML on a Nano 33 BLE, we need the vocabulary. Just enough to discuss training, classification, neural networks, and overfitting — without scary maths. By the end of this lesson you will:

1. Define feature, label, training, inference, model.
2. Describe a simple neural network (input layer → hidden layer → output layer) with one analogy each.
3. Explain three common ML failure modes: underfitting, overfitting, training-on-bad-data.

Warm-Up 10 min

No hardware. Just paper.

The classic ML problem

Imagine a basket of fruit. You want a machine to sort "apple" from "banana". You measure 50 examples: length, width, weight. Each labelled apple or banana. You feed this to a learning algorithm. It builds a model that, given new measurements, predicts the label.

That's machine learning in one paragraph. Let's unpack each piece.

New Concept · The vocabulary 25 min

Five terms

The simplest model: a rule

Even before neural networks, classification can be a simple rule:

• If length / width > 2 → banana.
• Else → apple.

Works ~95% of the time. Some apples are oblong, some bananas are short — accuracy isn't 100%. ML algorithms find better rules, especially when features interact in non-obvious ways.

The neural network analogy

Imagine 3 layers of small judges:

1. Input layer: takes the features (length, width, weight).
2. Hidden layer: each "neuron" looks at all inputs, weights them, decides "does this look like X?" (X might be "long thing" or "light thing" or "round thing" — the network learns what X means).
3. Output layer: takes the hidden layer's votes, decides "apple" or "banana".

Training adjusts the weights between layers so the predictions match the labels. Modern deep networks have many hidden layers and millions of weights — but the principle is the same.

Three failure modes

1. Underfitting: model too simple. Can't separate apples from bananas. Solution: more features, bigger model.
2. Overfitting: model memorises the training data. Perfect on training fruits, terrible on new ones. Solution: more data, simpler model, regularisation.
3. Training-on-bad-data: if your 50 bananas were all yellow and your 50 apples all red, the model learns "colour" — then a green apple looks like a banana to it. Solution: representative training data.

The training/test split

Take your 50 fruits. Use 40 for training; hold back 10 for "testing". Train on the 40. Predict on the 10. The test accuracy is your honest estimate of how good the model is. If training accuracy is 100% but test is 60%, you've overfit.

Edge AI workflow recap

From L04-31:

1. Collect features (sensor readings) labelled with the right class.
2. Train a small model.
3. Validate with a held-out test set.
4. Convert the model to TFLite Micro format.
5. Deploy onto Nano 33 BLE Sense.
6. Inference at runtime on live sensor data.

Worked Example · Tiny dataset on paper 25 min

Imagine 10 fruits:

Find a rule by inspection

Length > 10 → banana. Else → apple. 100% on this dataset.

Is weight useful?

Both apples (120–180 g) and bananas (100–130 g) overlap. Weight alone is a worse feature than length. ML algorithms automatically weigh features by usefulness.

What if you add "orange"?

Oranges might be 7 cm × 150 g. Indistinguishable from apples by length alone. Need a third feature: colour, shape, surface texture. Algorithms can handle 10s or 100s of features.

What if a label is wrong?

Suppose you accidentally label fruit #6 (the 20 cm one) as "apple". Now the "length > 10" rule fails on it. ML training is robust to a few wrong labels — averages them out across many examples. But many wrong labels = bad model.

Try a tiny neural network mentally

Hidden neuron: "is length > 12?". Output: "if hidden neuron says yes, banana; else apple". That's a 1-neuron network. Real networks have hundreds, learning combinations like "long AND lightweight = banana; round AND heavy = apple".

Try It Yourself · Pen-and-paper 15 min

Mini-Challenge · Design a dataset 10 min

You want to recognise three gestures with the Nano 33 BLE Sense: wave, punch, clap.

1. How many examples per gesture do you need? (50 is a starting point.)
2. What variation should each gesture include? (Different speeds? Both hands? Multiple people?)
3. What's the feature representation? (Raw accel sequence? Summary statistics?)
4. How would you split into train / test? (80 / 20 standard.)

Recap 5 min

ML vocabulary: feature, label, dataset, training, inference. Models learn from labelled examples; performance depends on data quality + representation. Watch for underfit / overfit / bad data. Tomorrow we collect real training data from the Nano 33 BLE Sense.

Feature

A measurable input variable. For gesture recognition: accelerometer values over time.

Label

The correct answer for one example ("wave", "punch").

Dataset

A collection of labelled examples.

Training

The process of learning model parameters from the dataset.

Inference

Using the trained model to predict the label for new data.

Model

The learned mathematical function mapping features to predictions.

Underfitting

Model too simple; poor on both train and test.

Overfitting

Model memorises training data; great on train, bad on test.

Train / test split

Holding back some data to honestly evaluate the model. 80/20 typical.

Class imbalance

One label has many more examples than another. Skews training; needs careful handling.

Neural network

A model made of layered "neurons" that combine features non-linearly. The dominant model class today.

Homework 5 min

1. Sign up for Google Colab if you haven't. Free Python ML environment.
2. Read ahead to ARD-L04-33 (Capturing Training Data). Bring the Nano 33 BLE Sense + a laptop.