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.

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: One-Class SVM for Novelty Detection

Ratkaisu

Awesome!

Challenge: One-Class SVM for Novelty Detection

Ratkaisu