Isolation Forest: Follow One Point Through a Forest

September 2026 · 12 min read

Put five observations on a number line: $X_{\text{train}} = \{1, 2, 3, 4, 20\}$. Most of the span $[1, 20]$ lies in the empty gap between $4$ and $20$. A uniform random cut landing in $(4, 20)$ immediately separates $20$ from the other four observations. Isolation Forest turns this geometric property into a score: observations isolated in fewer random cuts receive higher anomaly scores.

A random cut is uniform in feature space

At each internal node, an isolation tree picks a feature at random and draws a split threshold $q \sim \mathrm{Uniform}(\min x, \max x)$ between the node's observed minimum and maximum. It splits the rows into left ($x \le q$) and right ($x > q$) children without using labels or class purity (Liu, Ting & Zhou, 2008).

On $X_{\text{train}} = \{1, 2, 3, 4, 20\}$, the root cut interval has length $20 - 1 = 19$:

• Isolating $20$ on cut 1: requires $q \in (4, 20)$, which has length $20 - 4 = 16$, so $P(\text{isolate } 20) = \frac{16}{19} \approx \mathbf{84.2\%}$.
• Isolating $1$ on cut 1: requires $q \in [1, 2)$, which has length $2 - 1 = 1$, so $P(\text{isolate } 1) = \frac{1}{19} \approx \mathbf{5.3\%}$.
• Interior points ($2, 3, 4$): cannot be isolated by a single threshold on this feature ($0\%$ on cut 1).

Splitting continues until a row is alone in its leaf, all rows at the node have identical values, or the tree reaches its depth limit $\lceil \log_2 \psi \rceil$, where $\psi$ is the tree's subsample size.

Follow an actual fitted tree and its leaf correction

The interactive figure below shows a reproducible `scikit-learn` fit with $T = 3$ trees, subsample size $\psi = 5$, and `random_state=1`. The depth limit is $\lceil \log_2 5 \rceil = 3$. When a query $x$ reaches a leaf $L_t(x)$ at edge depth $e_t(x)$ containing $n_{\text{leaf}} = |L_t(x)|$ training rows, its corrected path length in tree $t$ is:

where $e_t(x)$ counts the cuts traversed from root to leaf, and $c(n_{\text{leaf}})$ adds the expected remaining cuts needed to isolate $n_{\text{leaf}}$ unsplit rows. For a singleton leaf ($n_{\text{leaf}} = 1$), $c(1) = 0$; for a two-row leaf ($n_{\text{leaf}} = 2$, such as $\{3, 4\}$ at depth $3$), $c(2) = 1$, giving $h_t(3) = 3 + 1 = 4$.

Convert the average path into a normalized anomaly score

A tree built on a larger subsample $\psi$ produces deeper paths on average. Isolation Forest normalizes the mean corrected path $\bar{h}(x) = \frac{1}{T}\sum_{t=1}^T h_t(x)$ by the expected path length $c(\psi)$ of an unsuccessful search in a Binary Search Tree on $\psi$ nodes:

where $H_{n-1}$ is the harmonic number. In scikit-learn's implementation, $c(1) = 0$, $c(2) = 1$, and for $n > 2$ the harmonic number is approximated by $H_{n-1} \approx \ln(n-1) + \gamma$ (with Euler's constant $\gamma \approx 0.57721566$). Plugging in $\psi = 5$:

The normalized anomaly score $s(x) \in (0, 1]$ is then defined as:

where:

• $\bar{h}(x)$ is the mean corrected path length of $x$ across all $T$ trees (averaged before exponentiating),
• $c(\psi)$ is the reference path length for subsample size $\psi$ ($s(x) = 0.5$ when $\bar{h}(x) = c(\psi)$; shorter paths yield $s(x) \to 1$).

Three output names, two different decisions

Scikit-learn exposes three related quantities from the same fitted forest:

• Anomaly score $s(x)$: higher means more unusual ($s(x) = 2^{-\bar{h}(x)/c(\psi)}$).
• score_samples(x): returns $-s(x)$, reversing the sign so lower (more negative) values mean more unusual.
• decision_function(x): shifts score_samples(x) by the threshold offset_: $$\mathrm{decision\_function}(x) = \mathrm{score\_samples}(x) - \mathrm{offset\_} = -s(x) - \mathrm{offset\_}$$ When $\mathrm{decision\_function}(x) < 0$, predict(x) returns $-1$ (outlier); otherwise $+1$ (inlier).

import numpy as np
from sklearn.ensemble import IsolationForest

X_train = np.array([1, 2, 3, 4, 20], dtype=np.float32).reshape(-1, 1)
X_query = np.array([1, 2, 3, 4, 20, 100], dtype=np.float32).reshape(-1, 1)
model = IsolationForest(
    n_estimators=3, max_samples=5, contamination="auto", random_state=1,
).fit(X_train)

unusualness = -model.score_samples(X_query)
decision = model.decision_function(X_query)
print(np.round(unusualness, 4))
# [0.6087 0.4092 0.3038 0.3038 0.6722 0.6722]

Structural limits of axis-aligned cuts

Notice that queries $20$ and $100$ traverse the exact same branches and receive identical scores ($s(20) = s(100) = 0.6722$). Once a query exceeds the highest split threshold in a tree, it lands in the outermost leaf—trees do not extrapolate distance beyond training cuts. Likewise, monotone nonlinear transforms (like $\operatorname{log1p}$) preserve sorting order but compress tail intervals, changing the probability of isolating extreme points—covered next in the telemetry chapter.

References and further reading

• Liu, Ting & Zhou: Isolation Forest — Random partitioning, average path lengths, subsampling, and the reference-length score.
• scikit-learn: IsolationForest — Parameters and score/predict conventions; the example was run with version 1.9.1.
• scikit-learn 1.9.1 source — The actual depth correction, normalization, score transform, and contamination offset used for these numbers.