✔️ Linting Passed

All linting checks passed. Your pull request is in excellent shape! ☀️

_{Generated for commit: acaa721. Link to the linter CI: here}

For completeness and self containment of the PR, can you link/copy the code and relevant results comparing poisson and MSE?

Thanks!

Benchmark script:

from time import perf_counter
import numpy
from sklearn.tree import DecisionTreeRegressor

if __name__ == "__main__":
    d = 20
    n = 3_000_000 // d
    n_fit = 10
    for criterion in ["squared_error", "poisson"]:
        dt = 0
        for _ in range(n_fit):
            X = numpy.random.rand(n, d)
            y = numpy.random.rand(n) + X.sum(axis=1)
            t = perf_counter()
            tree = DecisionTreeRegressor(max_depth=4, max_features=d,
                                        criterion=criterion).fit(X, y)
            dt += perf_counter() - t
        print(f"{criterion}: {dt / n_fit:.3f}s")

Results:

squared_error: 0.990s
poisson: 1.139s

Also a flame graph for a run with just criterion="poisson" showing that sort dominates (and hence, poisson loss computation is not very significant in the exec time):

@thomasjpfan do you have an historical context why the docs say poisson is much slower than MSE?

historical context why the docs say poisson is much slower

The PR that added poisson loss: #17386

The original code was basically the same as today.

I quickly browsed the reviews and I think this statement was just not challenged (which seems fair, I tend to challenge people when say it's fast but much less when they say it's slow 😂 ).

My hypothesis: it's true that the criterion-related computations are much slower for Poisson loss than for MSE, that's why the PR author added this comment. But because tree building is sort-dominated, this doesn't change much the total exec. time.

From memory it was because the Poisson's node_impurity needs to recompute the loss by going through the data again:

where MSE can compute the node_impurity without going through the data:

Although, "much slower" could be an overstatement. @lorentzenchr Do you recall why poisson was marked as "much slower" in the docs?