Decision Trees

This cover sets the central metaphor for the whole topic: a decision tree is a flowchart the algorithm built for itself. Most learners arrive expecting equations because that's what 'machine learning' implies, so naming the model as pure questions-and-answers reframes it as something they already understand intuitively.

The post that follows is deliberately the 'map' angle. We're not yet justifying why trees matter or how they're trained — we're nailing down what the object IS and the words used to describe it, so the later posts have solid ground to stand on.

The definition slide reframes prediction as a walk down a flowchart rather than a calculation. The key insight to internalize is that a tree stores no weights and runs no arithmetic on the features beyond comparisons — it stores a set of learned questions and the route between them.

The house/loan style examples are chosen because thresholds like 'age > 30' or 'income > 50k' map directly onto how a person would reason informally. That correspondence is exactly why trees are so easy to explain to non-technical stakeholders, a theme we return to hard in post 2.

This slide locks down the anatomy vocabulary because every later post leans on it. The root is special only in being first; mechanically it's the same kind of object as any internal node. Branches are not data — they're just the labeled edges (the yes/no answer) connecting a question to the next question.

Leaves are where the prediction actually lives. For classification a leaf stores the majority class of the training rows that landed there; for regression it stores their average. Getting students to picture data 'flowing down' into leaves is the mental model that makes the training process in post 3 click.

The tree diagram makes the abstract anatomy concrete with a loan-approval example. Reading it top-down — income, then home ownership — shows how each deeper question is asked only within the context set by the answers above it. That nesting is the source of a tree's power and is worth pausing on.

Notice the asymmetry: the 'income <= 50k' branch ends immediately at 'Deny' while the high-income branch keeps splitting. Trees don't have to be balanced; a branch stops as soon as its group is pure enough or a stopping rule fires. This previews the greedy, data-driven growth covered later.

Showing the tree as nested if/else statements bridges the gap for anyone with a programming background. It makes vivid that a trained tree is genuinely executable logic, not a statistical abstraction — you could transcribe it into code by hand and get identical predictions.

This equivalence is also why trees are trivially fast at inference and why they're so auditable. There's no hidden state to interpret: the entire decision procedure is a finite, readable set of conditions, which is precisely what regulators and stakeholders want to see.

The comparison slide prevents a common confusion: that 'decision tree' means one fixed thing. The same growth algorithm produces classification or regression trees depending on what's in the leaves and how splits are scored. Classification leaves vote a class and splits chase label purity; regression leaves average a number and splits chase variance reduction.

Making this distinction early matters because the impurity discussion in post 3 (Gini, entropy) is a classification concept, while regression trees minimize variance instead. Flagging the fork now means that post doesn't have to constantly caveat itself.

Depth is introduced here as the master dial because it's the concept that ties the whole topic together. A shallow tree underfits — too few questions to capture the pattern. An unbounded tree overfits — it keeps splitting until it has memorized the training set. Everything about regularizing trees is, at root, about controlling effective depth.

Flagging depth this early plants the seed for the overfitting discussion in posts 3 and 5. By the time learners see a depth-vs-accuracy curve later, they already expect that 'more depth' is not 'more better,' which makes the bias-variance lesson land instead of surprising them.

This four-line code slide gives readers something concrete to anchor on before the deeper mechanics. The point is psychological as much as technical: fitting a tree in scikit-learn really is this short, which lowers the intimidation barrier.

The max_depth=3 argument is included deliberately even in this intro snippet, because an unbounded default tree is one of the headline mistakes in post 5. Modeling the good habit from the very first code sample reinforces it without lecturing.

This slide walks through inference for a single row, which is the simplest possible operation a tree performs and a good sanity check on the mental model. Emphasize that prediction touches only the features named along one path — most features may never be consulted for a given row.

That path-based behavior explains two later facts: trees are extremely fast at prediction time, and a single row's prediction has a clean, human-readable explanation (the exact sequence of comparisons it passed). Both are selling points developed in post 2.

The flow diagram abstracts the growth process into five stages without yet naming the math. It's intentionally a teaser for post 3: 'split on the best feature' is doing enormous hidden work that Gini and information gain will unpack.

Showing groups getting 'purer' at each stage primes the central idea that splitting is purification. Even at this map-level post, ending on 'Leaves = decisions' reinforces that the entire structure exists to route rows to a final answer.

This recap consolidates the five vocabulary terms into a single reference slide so a reader can screenshot it and have the whole anatomy in one frame. Spaced repetition of root/node/branch/leaf/depth across the post is intentional — these words appear constantly in the next four posts.

The one term doing extra duty is depth, listed last so it lingers. It's the bridge to the 'why it matters' and 'how it works' posts, where depth becomes the knob that decides whether a tree is useful or useless.

The CTA closes the loop and points forward to post 2's argument. Framing the next post around stakeholder trust and the forest/boosting connection gives readers a concrete reason to continue rather than a generic 'follow me.'

It also sets expectations: post 1 was the what, post 2 is the why. Naming that progression helps readers see the series as a structured course rather than disconnected tips.