PYTHON · NUMPY

Learn From Data

You train a decision tree on sensor readings and it splits on front distance only. Where does it fail?

Train a simple classifier mapping sensor readings to a discrete action and run it on the rover, meeting held-out accuracy >= 0.85 and goal completion with zero collisions.

01Challenge

The rover sits at a short corridor. Sensors expose front_dist, goal_dist, heading_err; three discrete actions FORWARD/SLOW/TURN. A panel shows 40 expert-labeled points. Make the rover finish the course by deciding an action every tick, but you may NOT write more than 3 if statements. The trap: the labels overlap in the 0.18-0.35 m band depending on heading_err, so three thresholds can't separate SLOW from TURN.

Predict firstYou train a decision tree on sensor readings and it splits on front distance only. Where does it fail?

02Model

Last module you told the rover every rule: a threshold here, an if there. That works until the right answer depends on two things at once. One straight cut can't separate these points: the amber and white overlap on a single axis, so no three ifs get it right.

A classifier doesn't take a rule from you. It takes examples and finds the boundary that separates them. Give it both features and the cut can tilt and wrap around the overlap; the rule emerges from the data. Every tick, the rover's live reading is just a new point, and which region it lands in is its decision.

▶ Live · scrub & hover: labeled examples define the line that separates the classes

03Guided practice

Step 1 (worked): plot the labeled set and see the interleave. Step 2 (worked): fit a small decision tree (max_depth=3) and read train accuracy. Step 3 (faded): write the 70/30 split, fit on train, score on test, tune max_depth (depth 8 just memorizes 28 points). Step 4 (independent): wire clf.predict into the live control loop.

04Feedback

PASS WHEN Held-out action accuracy >= 0.85 on the 30% holdout, reaches the goal with zero collisions on C1, and also reaches goal on unseen seed 332.

If your run fails, check:

FAIL: test_acc below 0.85. Boundary mislabels SLOW<->TURN; the tree split on front_dist only, but heading_err is needed to separate the overlap.
FAIL: collided. Predicted FORWARD while front_dist was small; feature vector may be unscaled/misordered, print feat at the collision tick.
FAIL: passed seed 331 but failed generalization seed 332. You fit on all 40 points; refit on the train split only.

05Retrieve & space

From 2.1: apply your EMA filter to heading_err before predict. Does course completion get steadier? (Yes: noisy features jitter across a sharp boundary.)
From 2.2: which of the three actions is really a continuous control problem in disguise? (TURN: classification suits the discrete mode choice.)
From 1.3: how many `if` lines would a max_depth=3 tree compile to? A tree IS learned ifs.

06Mastery & project

Trained classifier reaches held-out accuracy >= 0.85, drives to goal completion with zero collisions on C1, and generalizes to unseen seed 332 (L3: produce a generalizing decision rule from labeled data and deploy it).

Feeds the capstone (5.1) as the rover's discrete mode selector; packaged as doorway_policy(state) -> Command(heading=...) so the learned discrete decision becomes a target heading the Module-2 PID can hold.

← Plan With a State Machine Reinforcement Learning →

PYTHON · NUMPY

Learn From Data

Fit a small decision tree on the two informative features, then drive the rover with its predictions.

You read

the arrays and values already in scope

You change

the code you write in each cell

Fixed

the dataset and the checks that grade you