Summary  
This chapter covers implementing One-Class SVM with grid search hyperparameter tuning for novelty detection, showing how to select optimal kernel and nu parameters and fit the model to identify outliers.

General domain of usage  
Fraud detection

import unittest
import numpy as np
import re
from sklearn.svm import OneClassSVM
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):
    """Structural validation for One-Class SVM challenge."""

    def test_variables_declared(self):
        import user_code
        required = ["X_train", "X_test", "model", "preds", "anomaly_fraction"]
        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_svm(self):
        import user_code
        cond = isinstance(user_code.model, OneClassSVM)
        _dynamic_test(
            self, cond,
            "`model` is a OneClassSVM instance.",
            "Expected `model` to be sklearn.svm.OneClassSVM."
        )

    def test_model_fitted(self):
        import user_code
        try:
            preds = user_code.model.predict(user_code.X_test)
            cond = isinstance(preds, np.ndarray)
        except NotFittedError:
            cond = False
        _dynamic_test(
            self, cond,
            "The One-Class SVM is fitted before prediction.",
            "Expected `model.fit(X_train)` before predicting."
        )

    def test_predictions_exist(self):
        import user_code
        cond = isinstance(user_code.preds, np.ndarray)
        _dynamic_test(
            self, cond,
            "`preds` array exists after prediction.",
            "Expected `preds` to be a NumPy array."
        )

    def test_anomaly_fraction_computed(self):
        import user_code
        cond = hasattr(user_code, "anomaly_fraction") and isinstance(user_code.anomaly_fraction, (float, np.floating))
        _dynamic_test(
            self, cond,
            "`anomaly_fraction` is computed as a float.",
            "Expected numeric variable `anomaly_fraction`."
        )

    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 sklearn operations used (no loops).",
            "Detected manual loop; expected sklearn vectorized API."
        )

    def test_prints_present(self):
        with open("user_code.py", "r") as f:
            src = f.read()
        cond = all(k in src for k in ["print", "anomalies", "fraction"])
        _dynamic_test(
            self, cond,
            "Print statements are present for output summary.",
            "Expected print statements showing anomaly stats."
        )

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.

Challenge: One-Class SVM for Novelty Detection

Oplossing