As an engigneer, not as a full time data scientist, I occasionally touch machine learning. Each time when I use LightGBM, I look around and thought I understand it.

While next time when I use it, I realize I actually don't understand it that well. There is no musle memory of how it works.

The documentation explains the algorithms, but I needed to see it. So I built this visualizer to watch predictions flow through the trees, step by step.

Imagine throwing a ball to hit a target. Your first throw gets close but misses. Each subsequent throw isn't aimed at the target itself - it's aimed at correcting your previous error. You're constantly pulling your prediction toward the accurate point.

That's exactly how LightGBM works. It starts with a rough prediction (the mean of training data, around $180k for house prices). Then each tree looks at the error and says "you're off by $20k, let me pull you closer." The next tree: "still $10k off, let me pull more." Each tree tugs the prediction closer to the true value.

Crucially, LightGBM pre-applies the learning rate to leaf values during training. So you don't multiply by learning_rate when predicting - you just sum up all the tree outputs directly. This is different from the textbook formula but makes inference faster.

Tree 0 provides the base prediction. For a $325k house, it might predict $180k. That's the starting point - way off, but it gives us something to improve on.

Now each subsequent tree tries to reduce the error. Tree 1 sees "$180k but should be $325k" and outputs +$15k. Tree 2 adds +$12k. Tree 3 adds +$8k. Each correction gets smaller as we get closer to the target.

The model keeps pulling until the predictions converge. With 100 trees and learning_rate=0.2, we get to $297k - only 8.6% off from the actual $325k. Not perfect, but each tree brought us closer.

When you select a row in my visualizer, you see the path light up in gold. This shows exactly which branches the model takes for that specific house.

For example, a house with OverallQual=8 and GrLivArea=2000 might go: - Right at "OverallQual ≤ 7.5" (because 8 > 7.5) - Left at "GrLivArea ≤ 2034" (because 2000 ≤ 2034) - End up in a leaf predicting $189k

This happens in every tree. The model evaluates each condition, walks down the tree, and extracts a value from the leaf. Ten trees, ten values, all summed together.

The visualizer supports drag & drop for:

Drop a model file and it'll parse the trees. Drop data and you can click through predictions.

The center tree is your current focus, slightly tilted left/right panels show previous/next trees. It gives context - you can see the progression of the model.

If you have a binary LightGBM model (.bin or .model file), you need to convert it to text format for this visualizer:

The text format is human-readable and shows the complete tree structure. This is what the visualizer parses.

The visualizer is built with React. Not much abstraction to be simple to understand.

Train a LightGBM model, save it as text with model.save_model(), and drop it into the visualizer. Watch your predictions flow through the trees. It's oddly satisfying to see the algorithm work.

Understanding gradient boosting went from "yeah I get it" to "oh, THAT'S how it works" once I could see it. Sometimes you need to visualize to truly understand.