Summary  
This chapter introduces hyperparameter tuning via grid search for an Isolation Forest model, demonstrating how to define a parameter grid, implement code to fit and evaluate models, and select optimal parameters.

General domain of usage  
Anomaly detection

import unittest
import re
import numpy as np
from sklearn.ensemble import IsolationForest
from sklearn.exceptions import NotFittedError

def _dynamic_test(tc, cond, ok, fail):
    if cond:
        tc._testMethodName = ok
        tc.assertTrue(True, ok)
    else:
        tc._testMethodName = fail
        tc.fail(fail)

class TestUserCode(unittest.TestCase):
    """Checks structure and correct Isolation Forest implementation."""

    def test_required_variables_declared(self):
        import user_code
        required = ["X", "model", "scores", "preds"]
        cond = all(hasattr(user_code, v) for v in required)
        _dynamic_test(
            self, cond,
            "All key variables are declared.",
            f"Expected variables {required} to be defined."
        )

    def test_model_is_isolationforest(self):
        import user_code
        cond = isinstance(user_code.model, IsolationForest)
        _dynamic_test(
            self, cond,
            "`model` is an IsolationForest instance.",
            "Expected `model` to be sklearn.ensemble.IsolationForest."
        )

    def test_model_is_fitted(self):
        import user_code
        try:
            preds = user_code.model.predict(user_code.X)
            cond = isinstance(preds, np.ndarray)
        except NotFittedError:
            cond = False
        _dynamic_test(
            self, cond,
            "Isolation Forest model is fitted before prediction.",
            "Expected `model.fit(X)` to be called before prediction."
        )

    def test_scores_computed(self):
        import user_code
        cond = isinstance(user_code.scores, np.ndarray)
        _dynamic_test(
            self, cond,
            "Anomaly scores are computed using `decision_function`.",
            "Expected `scores` to be a NumPy array."
        )

    def test_predictions_exist(self):
        import user_code
        cond = isinstance(user_code.preds, np.ndarray)
        _dynamic_test(
            self, cond,
            "Predictions (`preds`) are computed using `.predict()`.",
            "Expected predictions to be computed."
        )

    def test_print_statements_present(self):
        with open("user_code.py", "r") as f:
            src = f.read()
        cond = all(x in src for x in ["print", "outliers", "scores"])
        _dynamic_test(
            self, cond,
            "Print statements included for outputs.",
            "Expected print statements showing outlier count and scores."
        )

if __name__ == "__main__":
    unittest.main()


test_code.py

A comprehensive, hands-on course exploring the theory, intuition, and practical implementation of outlier and novelty detection algorithms in Python. Learn to identify anomalies using statistical, isolation, density, and kernel-based methods, interpret results, and compare approaches for real-world applications.

Establish core concepts, terminology, and visualization techniques for anomaly detection.

Explore classical statistical and distance-based approaches for anomaly detection.

Delve into tree-based anomaly detection using Isolation Forest.

Investigate density-based anomaly detection with Local Outlier Factor.

Explore boundary-based novelty detection using One-Class SVM.

Compare algorithms, metrics, and trade-offs for real-world anomaly detection.

Challenge: Isolation Forest Implementation

Solution

Awesome!

Challenge: Isolation Forest Implementation

Solution