Summary  
This chapter demonstrates how to implement and tune the Local Outlier Factor algorithm by performing a grid search over its hyperparameters to detect anomalies in data.

General domain of usage  
Fraud detection

import unittest
import numpy as np
import re
from sklearn.neighbors import LocalOutlierFactor

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):
    """Structural tests for LOF implementation challenge."""

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

    def test_model_is_lof(self):
        import user_code
        cond = isinstance(user_code.model, LocalOutlierFactor)
        _dynamic_test(
            self, cond,
            "`model` is a LocalOutlierFactor instance.",
            "Expected `model` to be sklearn.neighbors.LocalOutlierFactor."
        )

    def test_predictions_exist(self):
        import user_code
        cond = isinstance(user_code.preds, np.ndarray)
        _dynamic_test(
            self, cond,
            "`preds` array exists after calling fit_predict.",
            "Expected `preds` to be generated from fit_predict."
        )

    def test_scores_exist(self):
        import user_code
        cond = isinstance(user_code.scores, np.ndarray)
        _dynamic_test(
            self, cond,
            "`scores` (negative_outlier_factor_) are extracted.",
            "Expected `scores` to be stored as a NumPy array."
        )

    def test_no_manual_loop(self):
        with open("user_code.py", "r") as f:
            src = f.read()
        cond = "for " not in src
        _dynamic_test(
            self, cond,
            "Vectorized operations used (no manual loops).",
            "Detected manual for-loop; expected sklearn vectorized API."
        )

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

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


test_main.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: LOF in Practice

Solution

Challenge: LOF in Practice

Solution