(Lesson 07.02 · 30 minutes · Your phone · Final project)

Your project.

Now it's your turn. Choose a problem the phone can recognize, fill in the card, build the model in the lab, test it where it'll be used and tell the story of how it went, including what doesn't work.

What you learn

How to choose a problem you can see through to the end
Why it pays to train early, with little data
How to test a model in the real place
How to tell the story of a project so it's useful to someone

You need to know

If you don't remember one of these, the link takes you to the chapter that explains it.

How do you want to follow it

Preparing the scene…

01 The problem
Choose a small, real problem.

The final project starts from a question of your own. It has to be about something you see, hear or move every day, and that one of the phone's sensors can pick up. The noise of the boiler, the plants in the garden, the way you carry your backpack. The smaller and more concrete the problem, the easier it is to see it through to the end.

In practice. Drop the problems where even you can't give the right answer. If you can't label an example, the model can't learn it.
02 The card
The card sets the rules before you start.

Before you collect any data, fill in the card below. If you started it in The Basics, you'll find it already filled in. The question, the sensor, the possible answers, where it'll be used, and which mistake costs the most. These are the decisions that guide everything else, and writing them down first keeps you from changing them halfway through.

In practice. Have someone who doesn't know the project read the card. If they ask you questions, the card isn't clear yet.
03 The data
Collect a little, right away, in the real place.

Do a small first collection, twenty examples per class, in the place and in the way you'll use the model. Train right away, even if the result will be poor. It helps you find problems early, like two classes that get mixed up, or a shortcut^02.02 in the background. Then collect more, only where it's needed.

In practice. Keep a collection logbook with the date, the place and the conditions. You'll need it to split off the test data properly.
04 The model
In the lab, with the right input.

In the lab, choose the input for your sensor and the task. You can classify, estimate a number or find anomalies. While the model is learning, watch the two curves, and at the end, the confusion matrix^06.01. Repeat until the mistakes that are left have a reason you understand.

In practice. Change one thing at a time from one training run to the next, and write down what you changed. Otherwise you'll never know what made the model better.
05 The real test
Test it where and how it'll be used.

The tests in the lab aren't enough. Take the phone to the real place, with the real light and the real people, and count the right and wrong answers on at least fifty cases. Measure the latency^01.01 too, and the battery after ten minutes. Those are the numbers that matter to the people who'll use the model.

In practice. Save the examples the model gets wrong in the real test. They're the most valuable ones for the next round of training.
06 In your pocket
Slim it down and test it in airplane mode.

When the model works well, apply 8-bit quantization^01.05 and compare size and accuracy. Put the phone in airplane mode and try the model again in the browser where you trained it. If everything works, your model really is edge AI^01.01. It runs in your pocket, without a network, and the data never leaves the phone.

In practice. If the 8-bit model loses too much on one class, collect more examples of that class before going back to 32 bits.
07 The story
Write down what you did, including what doesn't work.

The last step is to tell the story of the project on a single page. The question, the data, the model, the numbers from the real test, and what's missing. Write honestly about where it goes wrong and why. This page is called a model card, and it's worth as much as the model, because whoever reads it knows when to trust it.

In practice. Go through the checklist below before you say you're done. If something is missing, go back to that step before you say you're done.

01 / 07

(Go deeper)

A few more numbers.

(01)

Project ideas, one sensor at a time

If you don't have a problem yet, start from a sensor and a place you know well. The table lines up a few ideas, one for each input in the lab. Each one comes from things that really happen at home, in the garden or at work.

Pick the one where you can give the right answer with no doubts, and where you can collect the examples in a week. The rest follows from there.

Input	Question	Possible answers
Photo	Does this plant in the vegetable garden need water?	Yes, no, not sure
Sound	Is the boiler making its usual noise?	Normal, strange
Motion	Am I carrying my backpack the right way?	Straight, crooked, no backpack
Hand	Which sign am I making to the camera?	Three signs you choose, and nothing
Text	Is this group chat message an important notice?	Notice, chatter

(02)

The model card

In 2019 Margaret Mitchell and her colleagues at Google proposed model cards, short pages that come with each model. Today you'll find them next to almost every published model. They say what the model is for, what data it was trained on, how it was measured and where it shouldn't be used.

For a small project, six lines are enough. The purpose, the data with how many examples and where you collected them, the starting model, the numbers from the real test, the cases where it goes wrong, and what stays on the phone. Writing it forces you to know these things, and it's the most honest test of your work.

(03)

After the course

The lab takes you as far as a model that works in the browser and in airplane mode. To go further, the steps are the ones in the course From model to app. You export the model, choose an engine like LiteRT or Core ML, measure it on your reference phone and put it in a real app.

Later on, you'll also be able to do this course's exercises with Edgy Studio, the app for collecting and labeling datasets from your phone. The method stays the same seven steps, from the question to a phone that answers without a network.

(Try it on your phone)

Your project card

This is the same card you started in The Basics, with three more rows. If you filled it in, you'll find it here. It saves itself in your browser.

The final checklist

(01) Every row of the project card is filled in
(02) I have at least 20 examples per class, collected in the real place
(03) The test examples come from a separate session
(04) I looked at the confusion matrix and I understand the mistakes that are left
(05) I tested the model in the real place on at least 50 cases
(06) I measured milliseconds and battery on my phone
(07) The 8-bit model works in airplane mode
(08) I tested the model with people other than me, and the result holds for each of them
(09) Everyone who appears in the data said yes, and I know which examples are theirs
(10) A line in the app says where the model goes wrong
(11) I wrote the model card, including what's missing

When you've checked off everything, the project is finished, for now. A real model is never completely finished. It gets better every time you test it in a new place.

(Quiz)

4 questions to close the lesson.

When you have answered them all, the lesson counts as done and its stone on the map turns yellow. Answering is what counts, not the score.

(01)

Which problem should you choose for the final project?
(02)

Why should you train right away with just a few examples?
(03)

Where does the test that counts happen?
(04)

What should the model card say?

New words, and where they are explained

Model cardchapter 7

Sources and reading

To close the lesson, answer the quiz

← A real case, the olive leaf The course review Back to the map

(End of the course)Your certificate