Choosing Your Tool

Choosing the tool

Twelve chapters ago, a "model" was a mystery. Now you can fit a line, grow a forest, stack a deep network, slide a convolution across an image, pass messages on a graph, denoise an image into existence, and train an agent by reward. The remaining skill is picking the right one. Given a problem you have never seen, how do you choose?

Ask which assumptions fit our data, not which model has the biggest reputation.

The five questions

Use the first two questions to narrow the field, then the last three to break ties.

These are starting points to measure, not guarantees. Make a deep network earn its complexity against a baseline that fits the problem.

Six problems, six choices

Scenario 1: predict a house's price from a spreadsheet of features: square footage, bedrooms, zip code. Shape: a table. Learn from: labels, since each house has a sold price, a number, so this is regression. Size: a few thousand rows. Verdict: start with plain linear regression as a baseline, which takes seconds, then reach for gradient-boosted trees from the classical toolbox for accuracy. With a few thousand rows, make a neural network earn its extra training effort against that baseline.

1. ShapeTable.
2. SignalNumeric labels: regression.
3. First trialLinear baseline, then boosted trees.

Scenario 2: split your customers into natural groups you never defined in advance. Shape: a table again. Learn from: no labels at all, because nobody tagged these customers. Verdict: this is unsupervised, so k-means to find the clusters and PCA to squash the features down and see them, both from the classical toolbox. With no labels there is nothing for a network to fit; find the structure that is already there.

1. ShapeCustomer rows.
2. SignalNo labels: find structure.
3. First trialk-means groups; PCA view.

Scenario 3: flag likely pneumonia on chest X-rays. Shape: a grid of pixels, where a pixel's meaning is set by its neighbors. Learn from: labels, namely radiologist-confirmed cases. Size: large. Verdict: a convolutional neural network from seeing machines, the tool built for grids, likely starting from one pre-trained on millions of images and fine-tuned on the X-rays. There is a tension here: medicine wants explanations, and a CNN is less transparent than a tree, so in practice it is paired with heat-maps showing where it looked, with a doctor in the loop. The grid makes a CNN a useful candidate; heat maps alone do not establish that its decisions are sound.

1. ShapePixel grid.
2. SignalConfirmed case labels.
3. First trialFine-tune a CNN; check errors and explanations.

Scenario 4: build a support chatbot that answers in fluent prose. Shape: a sequence, because language carries its meaning in order and long-range context. Learn from: a mountain of unlabeled text (self-supervised pretraining) plus human preferences for the polish. Verdict: a transformer, which is a large language model, the subject of the entire sister site, finished with the RLHF from learning by doing to steer it toward helpful behavior, which still needs evaluation. The shape (a sequence) and the task (generation) both point at one family.

1. ShapeText sequence.
2. SignalText, then preferences.
3. First trialPre-trained language model; evaluate helpfulness.

Scenario 5: teach a warehouse robot to grasp and stack items nobody demonstrated. Shape: a stream of decisions over time. Learn from: no labeled "correct grasp" exists, only a reward when the item ends up stacked. Verdict: reinforcement learning from learning by doing, trained in a physics simulator where it can fail ten thousand times without damaging hardware before touching a real shelf. No labels and a reward per outcome is what RL is for.

1. ShapeActions over time.
2. SignalReward for stacking.
3. First trialReinforcement learning in simulation.

The one where the answer is a graph network

Scenario 6: triage whether a cluster of accounts is a coordinated network from its contact pattern, before reading the traffic. Run the five questions:

The contact pattern is the evidence: a hub coordinating several accounts can matter even when each account’s traffic looks ordinary. Historical labels tell us which whole clusters were coordinated, so this is supervised classification of graphs. With tens of thousands of labeled clusters, we can test whether learning those neighborhoods helps on unseen clusters. A graph network is a candidate because its wiring keeps that evidence available; the baseline and the held-out score still decide whether it earns its cost.

1. Shape: accounts are nodes; contacts are edges, with no natural starting account or left-to-right order.
2. Learning signal: historical clusters have known coordinated/not-coordinated labels: supervised classification.
3. Amount: tens of thousands of labeled clusters support learning; still test on unseen clusters.
4. Explanation: inspect which neighborhoods support the triage, and check whether that evidence meets the task’s needs.
5. Budget: compare a graph-aware model against a cheap baseline; preserve connections if they carry the answer.

A GNN starts each account with features such as volume, timing, and age; repeated message passing mixes its neighbors’ information. A readout pools the resulting vectors into a graph-level verdict. The representation preserves the connections that aggregate counts omit.

The same clue appears in fraud rings, recommendations, and road networks: ask whether relationships carry information beyond the individual entities.

Walk it yourself

Try the questions on your own problem. The chooser names a first model family, explains its recommendation, and links back to the relevant chapter.

1. Load presets: compare all six scenarios.
2. House prices: require an explanation for each decision; watch the advice favor a tree or linear model.
3. Coordinated net: change graph to table; the chooser now recommends boosted trees because the stated shape changed.

The controls describe the problem you give them; they cannot detect that you discarded useful connections. Start with the simplest fitting model, measure it, and add complexity only when the results justify it.

What to keep

You started this site unable to read a vector. You can now stand in front of an unfamiliar problem, read the shape of its data, name the family that fits, and say why. That includes saying that a boosted tree often beats a neural network, and that a web of relationships wants a graph network.

We kept returning to a flexible function, a loss, and gradient descent. Neural networks share this update; trees, neighbor methods, and other classical tools have their own fitting procedures.

In words: nudge every parameter ($\theta$, theta, the numbers the model learns) a small step of size $\eta$ (eta, the learning rate) against $\nabla L$, the gradient of the loss, which is the direction in which wrongness climbs fastest. A small enough step against it lowers the loss locally. For models trained this way the update has not changed since fitting a line. Choosing a model is choosing the shape that goes around it.

Where you've been