Separate a rule you hand-write from a pattern a model learns off graded examples, then tag the feature columns, target, and prediction in a real email table.

You could write `if subject contains "FREE" then spam` and ship it, but the moment a spammer types "Fr€€" your rule is dead. There is a second way to build that filter, and it never touches a keyword list.

Sort any problem into supervised, unsupervised, or reinforcement by the shape of its data, a filled answer column, no answers, or a reward earned by acting, never by its subject or algorithm.

Last topic you graded emails `spam` or `not-spam` and trained a filter, and that answer column is the whole reason it worked. Delete the column and you can still learn something from those emails, just not the same thing.

Trace one pass of the training loop, guess, measure the miss, nudge the weight, then predict what a too-big or too-small step does to the loss curve and when more passes stop paying off, all with zero math.

Last topic your filter could call an email `spam`, but nobody told it how. It starts out guessing, gets one number back for how far off it was, and quietly tunes itself, over and over, until the guesses stop missing.

Run any problem through a four-condition test to tell a hand-written rule from a trained model, then judge whether your data is enough, labeled, and representative before writing a line of code.

You could write `if income < 12000: tax = 0` in one line, and you should. Other problems bury their answer in examples no line you type will ever catch, and telling the two apart comes first.

Read any dataset's shape by one test, does scrambling its order destroy it, then match tabular, image, text, and time-series to the job each shape can feed.

A spreadsheet, a cat photo, a stock chart: three datasets, three shapes. Scramble each one's insides and only the spreadsheet, rows like `price=340k`, survives while the other two turn to noise, telling you what you hold.

Hold back a test set so a score means something, split a table at random but a stock chart by time, and catch the leak that makes a broken model look perfect.

A model scores 99% on the house table it studied, rows like `price=340k`, then flops on the next real listing. It recited rows it had seen, and one slice held back from the start keeps the score honest.

Read a predicted number off a line fitted to your data, catch when a straight line is the wrong shape for a curve, and distrust any prediction pushed past the range you measured.

A property site quotes the house on Maple Street at `$412,000`, and no agent typed that figure. A line drawn through thousands of past sales took the home's size and read the price straight off it.

Sort a case into one of two categories by which side of a line it falls on, read its confidence off how far it sits from that line, and move the cut-off to trade wrongly-flagged real mail against spam let through.

A spam filter never answers `0.72`; it answers spam or not-spam, a name from a short list. The same filter also knows how sure it is, and hands you a dial for which wrong picks you can live with.

Walk a loan application down a tree's yes/no branches to its verdict, see how one flipped answer reroutes it to the opposite call, and explain why a forest of disagreeing trees that vote beats a single tree that swings with its training data.

A loan officer never runs one formula; they ask `income > 50000?`, then a follow-up, then another, each answer narrowing toward approve or deny. A hundred officers who each ask different questions and pool their calls beat any single one.

Spot an overfit model by the gap between its training and test scores, tell that apart from a too-simple model weak on both, and close the gap with more data, a simpler model, or regularization.

A pricing model reports `train_score = 1.00`, a flawless run on every house it studied, so the team ships it. On a hundred houses it never saw, it misses nearly every price; the perfect number was the warning.

Read past a 99%-accurate screen into its four confusion-matrix cells, slide the threshold to trade false alarms against missed cases, and set the cut-off by which mistake costs most.

A screening model runs `return "healthy"` on all 1,000 patients, misses the single sick one, and still prints 99.9% on its report card. On paper it is the best model in the building, in the clinic it is worthless.

Re-shuffle a single train/test split and watch two close models trade first place, then rotate the held-out slice with cross-validation until the ranking holds, break ties toward the simpler model, and seal the test set so tuning never inflates the verdict.

Two spam filters score 98% and 97%, so you ship the first, then flip one line, `random_state=3`, re-shuffle the same rows, and now the 97% model leads. Nothing about either model changed.

Skew a hiring screener's training pile and watch its decisions tilt with no biased rule in sight, see why piling on more of the same data deepens the slant instead of fixing it, and carry two questions into every confident prediction: was the data representative, and is this a case the model has really seen.

Feed a hiring model ten years of past resumes with `model.fit(past_hires)` and let it decide who advances. It copies the pattern in that pile faithfully, including the one where nearly everyone hired before was a man.