{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "import sys\n",
        "!{sys.executable} -m pip install pyod\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import math\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.metrics import precision_score, recall_score, f1_score\n",
        "from scipy import stats\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "# PyOD detectors (work only with input features)\n",
        "from pyod.models import abod, hbos, iforest, knn, lof, ocsvm, pca, copod\n",
        "\n",
        "# Detectors that can take the target variable into account\n",
        "from sklearn.ensemble import IsolationForest as SklearnIForest\n",
        "from sklearn.svm import OneClassSVM\n",
        "from sklearn.covariance import EllipticEnvelope\n",
        "from sklearn.neighbors import LocalOutlierFactor\n",
        "from sklearn.ensemble import RandomForestRegressor\n",
        "from sklearn.neural_network import MLPRegressor\n",
        "\n",
        "# Autoencoder for outlier detection (PyTorch)\n",
        "import torch.nn.functional as F\n",
        "\n",
        "# ==========================================================\n",
        "# PART 1: CREATING THE \"PARABOLA\" DATASET WITH ONE OUTLIER\n",
        "# ==========================================================\n",
        "\n",
        "# ------------------------------------------------------------\n",
        "# 1. Initial data: 20 points, 19 lie on a parabola,\n",
        "#    and point #10 (x=13, y=75) is an outlier.\n",
        "# ------------------------------------------------------------\n",
        "data = [\n",
        "    (1, 1, 36), (2, 5, 4), (3, 6, 1), (4, 7, 0), (5, 8, 1),\n",
        "    (6, 9, 4), (7, 10, 9), (8, 11, 16), (9, 12, 25), (10, 13, 55),\n",
        "    (11, 14, 49), (12, 15, 64), (13, 16, 81), (14, 17, 100),\n",
        "    (15, 18, 121), (16, 19, 144), (17, 20, 169), (18, 21, 196),\n",
        "    (19, 22, 225), (20, 27, 400)\n",
        "]\n",
        "\n",
        "X = np.array([row[1] for row in data], dtype=np.float32).reshape(-1, 1)\n",
        "y = np.array([row[2] for row in data], dtype=np.float32).reshape(-1, 1)\n",
        "\n",
        "Q = X.shape[0]          # number of examples = 20\n",
        "outlier_idx = 9         # index of true outlier (example #10)\n",
        "N_x = X.shape[1]        # 1 input feature\n",
        "N_y = y.shape[1]        # 1 output variable\n",
        "\n",
        "# Create array of true outliers\n",
        "true_outliers = np.zeros(Q, dtype=int)\n",
        "true_outliers[outlier_idx] = 1\n",
        "\n",
        "# ------------------------------------------------------------\n",
        "# 2. Visualization of the original dataset (before scaling)\n",
        "# ------------------------------------------------------------\n",
        "plt.figure(figsize=(10, 6))\n",
        "\n",
        "# All points (blue - normal, red - outlier)\n",
        "colors = ['red' if i == outlier_idx else 'blue' for i in range(Q)]\n",
        "plt.scatter(X, y, c=colors, s=50, edgecolors='black', linewidth=0.5, zorder=5)\n",
        "\n",
        "# Specified outlier (example #10)\n",
        "plt.scatter(X[outlier_idx], y[outlier_idx], color='red', s=100,\n",
        "            linewidths=2, edgecolors='yellow', label='Outlier', zorder=10)\n",
        "\n",
        "# Add example numbers\n",
        "for i in range(Q):\n",
        "    color = 'red' if i == outlier_idx else 'blue'\n",
        "    plt.text(X[i, 0], y[i, 0] + 5, str(i+1), fontsize=9,\n",
        "             ha='center', va='bottom', color=color, fontweight='bold')\n",
        "\n",
        "# Approximating parabola using points without outlier\n",
        "good_mask = np.ones(Q, dtype=bool)\n",
        "good_mask[outlier_idx] = False\n",
        "X_good = X[good_mask].flatten()\n",
        "y_good = y[good_mask].flatten()\n",
        "coeffs = np.polyfit(X_good, y_good, 2)\n",
        "poly = np.poly1d(coeffs)\n",
        "X_smooth = np.linspace(X.min(), X.max(), 200)\n",
        "y_smooth = poly(X_smooth)\n",
        "plt.plot(X_smooth, y_smooth, 'g--', linewidth=2, label='Parabola (based on normal points)', zorder=1)\n",
        "\n",
        "plt.xlabel('X', fontsize=12)\n",
        "plt.ylabel('y', fontsize=12)\n",
        "plt.title('Original dataset: 19 points on a parabola and one outlier (#10)', fontsize=14)\n",
        "plt.legend()\n",
        "plt.grid(True, linestyle=':', alpha=0.7)\n",
        "plt.xticks(np.arange(0, X.max()+2, 2))\n",
        "plt.tight_layout()\n",
        "plt.show()\n",
        "\n",
        "# ==========================================================\n",
        "# PARAMETERS - ALL METHODS WILL SEARCH FOR EXACTLY ONE OUTLIER\n",
        "# ==========================================================\n",
        "print(\"\\n\" + \"=\"*60)\n",
        "print(\"OUTLIER DETECTION PARAMETER SETUP\")\n",
        "print(\"=\"*60)\n",
        "print(f\"The dataset contains {true_outliers.sum()} true outlier (proportion {true_outliers.sum()/Q*100:.1f}%)\")\n",
        "\n",
        "# Use default values\n",
        "Ksi = 0\n",
        "n_outliers_desired = 1  # ALL METHODS WILL SEARCH FOR EXACTLY ONE OUTLIER\n",
        "contamination = n_outliers_desired / Q\n",
        "contamination_percent = contamination * 100\n",
        "\n",
        "print(f\"✅ ALL methods will search for exactly {n_outliers_desired} outlier ({contamination_percent:.2f}%)\")\n",
        "print(f\"✅ Parameter Ksi = {Ksi} (neuron search range)\")\n",
        "\n",
        "# Helper function to get top-1 outlier\n",
        "def get_top1_prediction(scores):\n",
        "    \"\"\"Convert anomaly scores to binary prediction with exactly one outlier\"\"\"\n",
        "    pred = np.zeros(Q, dtype=int)\n",
        "    if len(scores) == Q:\n",
        "        top1_idx = np.argmax(scores)\n",
        "        pred[top1_idx] = 1\n",
        "    return pred\n",
        "\n",
        "# ==========================================================\n",
        "# NNFS ALGORITHM - MODIFIED TO FIND EXACTLY ONE OUTLIER\n",
        "# ==========================================================\n",
        "print(\"\\n\" + \"=\"*60)\n",
        "print(\"RUNNING NNFS ALGORITHM (FINDING EXACTLY ONE OUTLIER)\")\n",
        "print(\"=\"*60)\n",
        "\n",
        "def scale_to_minus1_1(data):\n",
        "    min_val = data.min(axis=0)\n",
        "    max_val = data.max(axis=0)\n",
        "    range_val = max_val - min_val\n",
        "    range_val[range_val == 0] = 1.0\n",
        "    scaled = 2.0 * (data - min_val) / range_val - 1.0\n",
        "    return scaled, min_val, max_val\n",
        "\n",
        "X_scaled_nnf, x_min, x_max = scale_to_minus1_1(X)\n",
        "y_scaled_nnf, y_min, y_max = scale_to_minus1_1(y)\n",
        "\n",
        "X_tensor = torch.tensor(X_scaled_nnf, dtype=torch.float32)\n",
        "y_tensor = torch.tensor(y_scaled_nnf, dtype=torch.float32)\n",
        "\n",
        "# Calculate hidden layer neuron count bounds\n",
        "log2q = math.log2(Q)\n",
        "N_min = (N_y * Q) / ((1 + log2q) * (N_x + N_y)) + 1 + 1\n",
        "N_max = (N_y / (N_x + N_y)) * ((Q / N_x + 1) * (N_x + N_y + 1) + 1) - 1\n",
        "\n",
        "# Limit maximum N value for 20 points\n",
        "if N_max > Q:\n",
        "    N_max = min(Q // 2, 15)\n",
        "\n",
        "N_lim = N_min + Ksi * (N_max - N_min)\n",
        "N_start = max(1, int(np.ceil(N_min)))\n",
        "N_end = max(N_start, int(np.ceil(N_lim)))\n",
        "\n",
        "print(f\"Q = {Q}, N_x = {N_x}, N_y = {N_y}\")\n",
        "print(f\"N_min = {N_min:.4f}, N_max = {N_max:.4f}\")\n",
        "print(f\"Ksi = {Ksi}, N_lim = {N_lim:.4f}\")\n",
        "print(f\"Loop over $N$ from {N_start} to {N_end} inclusive\")\n",
        "print(\"This may take some time...\")\n",
        "\n",
        "# Vector for storing errors for each N\n",
        "E_total = np.zeros(Q)\n",
        "E_list = []\n",
        "\n",
        "torch.manual_seed(42)\n",
        "\n",
        "for N in range(N_start, N_end + 1):\n",
        "    model = nn.Sequential(\n",
        "        nn.Linear(N_x, N),\n",
        "        nn.Tanh(),\n",
        "        nn.Linear(N, N_y),\n",
        "    )\n",
        "    criterion = nn.MSELoss()\n",
        "    optimizer = optim.Adam(model.parameters(), lr=0.01)\n",
        "\n",
        "    model.train()\n",
        "    for epoch in range(1000):\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(X_tensor)\n",
        "        loss = criterion(outputs, y_tensor)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        predictions = model(X_tensor).numpy().flatten()\n",
        "        errors = (predictions - y_scaled_nnf.flatten()) ** 2\n",
        "    E_total += errors\n",
        "    E_list.append(errors)\n",
        "    print(f\"  Completed N = {N}\")\n",
        "\n",
        "# Calculate average errors over all N\n",
        "E_avg = np.mean(np.array(E_list), axis=0)\n",
        "\n",
        "# NNFS: take exactly the most anomalous point (top-1)\n",
        "nnfs_pred = get_top1_prediction(E_avg)\n",
        "nnfs_outlier_idx = np.argmax(E_avg)\n",
        "\n",
        "print(\"\\n\" + \"=\"*50)\n",
        "print(\"NNFS RESULTS\")\n",
        "print(\"=\"*50)\n",
        "print(f\"Number of detected outliers: {nnfs_pred.sum()} (expected {n_outliers_desired})\")\n",
        "print(f\"Detected outlier index: {nnfs_outlier_idx+1}\")\n",
        "print(f\"Anomaly score: {E_avg[nnfs_outlier_idx]:.6f}\")\n",
        "\n",
        "# ==========================================================\n",
        "# PREPARE DATA FOR DETECTORS\n",
        "# ==========================================================\n",
        "# For methods working with feature space\n",
        "X_2d = np.column_stack((X.flatten(), y.flatten()))\n",
        "scaler = StandardScaler()\n",
        "X_scaled = scaler.fit_transform(X_2d)\n",
        "\n",
        "# ==========================================================\n",
        "# 1. METHODS THAT ANALYZE ONLY INPUT FEATURES (PyOD)\n",
        "# ==========================================================\n",
        "print(\"\\n\" + \"=\"*80)\n",
        "print(\"METHODS ANALYZING ONLY INPUT FEATURES (PyOD)\")\n",
        "print(\"=\"*80)\n",
        "print(f\"NOTE: Each method will return exactly ONE outlier (top-1 by anomaly score)\\n\")\n",
        "\n",
        "detectors_pyod = {\n",
        "    'ABOD (pyod)': abod.ABOD(contamination=contamination),\n",
        "    'HBOS (pyod)': hbos.HBOS(contamination=contamination),\n",
        "    'IsolationForest (pyod)': iforest.IForest(contamination=contamination, random_state=42),\n",
        "    'kNN (pyod)': knn.KNN(contamination=contamination),\n",
        "    'LOF (pyod)': lof.LOF(contamination=contamination),\n",
        "    'OCSVM (pyod)': ocsvm.OCSVM(contamination=contamination),\n",
        "    'PCA (pyod)': pca.PCA(contamination=contamination),\n",
        "    'COPOD (pyod)': copod.COPOD(contamination=contamination)\n",
        "}\n",
        "\n",
        "results_pyod = {}\n",
        "scores_pyod = {}\n",
        "pyod_predictions = {}\n",
        "\n",
        "for name, model in detectors_pyod.items():\n",
        "    try:\n",
        "        model.fit(X_scaled)\n",
        "        # Get anomaly scores\n",
        "        scores = model.decision_scores_\n",
        "        scores_pyod[name] = scores\n",
        "        # Convert to exactly ONE outlier (top-1)\n",
        "        pyod_predictions[name] = get_top1_prediction(scores)\n",
        "        print(f\"  ✓ {name} - detected {pyod_predictions[name].sum()} outlier(s)\")\n",
        "    except Exception as e:\n",
        "        print(f\"  ✗ Error training {name}: {e}\")\n",
        "        scores_pyod[name] = np.zeros(Q) - 1\n",
        "        pyod_predictions[name] = np.zeros(Q, dtype=int)\n",
        "\n",
        "# ==========================================================\n",
        "# 2. METHODS THAT CAN TAKE THE TARGET VARIABLE INTO ACCOUNT\n",
        "# ==========================================================\n",
        "print(\"\\n\" + \"=\"*80)\n",
        "print(\"METHODS ANALYZING INPUT FEATURES + TARGET VARIABLE\")\n",
        "print(\"=\"*80)\n",
        "print(f\"NOTE: Each method will return exactly ONE outlier (top-1 by anomaly score)\\n\")\n",
        "\n",
        "# 2.1. Random Forest (prediction error) - take top-1\n",
        "print(\"1. Random Forest Regressor...\")\n",
        "rf = RandomForestRegressor(n_estimators=100, random_state=42)\n",
        "rf.fit(X_scaled, y.ravel())\n",
        "rf_errors = (rf.predict(X_scaled) - y.ravel()) ** 2\n",
        "rf_pred = get_top1_prediction(rf_errors)\n",
        "print(f\"   ✓ Detected {rf_pred.sum()} outlier(s)\")\n",
        "\n",
        "# 2.2. Neural Network (prediction error) - take top-1\n",
        "print(\"2. Neural Network Regressor...\")\n",
        "mlp = MLPRegressor(hidden_layer_sizes=(20, 10), random_state=42, max_iter=500)\n",
        "mlp.fit(X_scaled, y.ravel())\n",
        "mlp_errors = (mlp.predict(X_scaled) - y.ravel()) ** 2\n",
        "mlp_pred = get_top1_prediction(mlp_errors)\n",
        "print(f\"   ✓ Detected {mlp_pred.sum()} outlier(s)\")\n",
        "\n",
        "# 2.3. Autoencoder (input feature reconstruction error) - take top-1\n",
        "print(\"3. Autoencoder (input feature reconstruction error)...\")\n",
        "class Autoencoder(nn.Module):\n",
        "    def __init__(self, input_dim, encoding_dim=2):\n",
        "        super(Autoencoder, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Linear(input_dim, 4),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(4, encoding_dim)\n",
        "        )\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.Linear(encoding_dim, 4),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(4, input_dim)\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        encoded = self.encoder(x)\n",
        "        decoded = self.decoder(encoded)\n",
        "        return decoded\n",
        "\n",
        "X_tensor_ae = torch.tensor(X_scaled, dtype=torch.float32)\n",
        "ae = Autoencoder(input_dim=X_scaled.shape[1])\n",
        "optimizer_ae = optim.Adam(ae.parameters(), lr=0.01)\n",
        "criterion_ae = nn.MSELoss()\n",
        "\n",
        "ae.train()\n",
        "for epoch in range(300):\n",
        "    optimizer_ae.zero_grad()\n",
        "    reconstructed = ae(X_tensor_ae)\n",
        "    loss = criterion_ae(reconstructed, X_tensor_ae)\n",
        "    loss.backward()\n",
        "    optimizer_ae.step()\n",
        "    if (epoch+1) % 50 == 0:\n",
        "        print(f\"    Autoencoder: epoch {epoch+1}/300, loss = {loss.item():.6f}\")\n",
        "\n",
        "ae.eval()\n",
        "with torch.no_grad():\n",
        "    reconstructed = ae(X_tensor_ae)\n",
        "    ae_errors = torch.mean((reconstructed - X_tensor_ae) ** 2, dim=1).numpy()\n",
        "ae_pred = get_top1_prediction(ae_errors)\n",
        "print(f\"   ✓ Detected {ae_pred.sum()} outlier(s)\")\n",
        "\n",
        "# 2.4. Combined method: Random Forest + Autoencoder - take top-1\n",
        "print(\"4. Combined method (Random Forest + Autoencoder)...\")\n",
        "combined_errors = (rf_errors / np.max(rf_errors) + ae_errors / np.max(ae_errors)) / 2\n",
        "combined_pred = get_top1_prediction(combined_errors)\n",
        "print(f\"   ✓ Detected {combined_pred.sum()} outlier(s)\")\n",
        "\n",
        "# 2.5. One-Class SVM with y added - take top-1\n",
        "print(\"5. One-Class SVM (with y added)...\")\n",
        "X_with_y = np.column_stack((X_scaled, y.ravel()))\n",
        "ocsvm_with_y = OneClassSVM(nu=contamination, kernel='rbf', gamma='auto')\n",
        "ocsvm_with_y.fit(X_with_y)\n",
        "ocsvm_with_y_scores = -ocsvm_with_y.decision_function(X_with_y)\n",
        "ocsvm_with_y_pred = get_top1_prediction(ocsvm_with_y_scores)\n",
        "print(f\"   ✓ Detected {ocsvm_with_y_pred.sum()} outlier(s)\")\n",
        "\n",
        "# 2.6. Isolation Forest with y added - take top-1\n",
        "print(\"6. Isolation Forest (with y added)...\")\n",
        "iforest_with_y = SklearnIForest(contamination=contamination, random_state=42)\n",
        "iforest_with_y.fit(X_with_y)\n",
        "iforest_with_y_scores = -iforest_with_y.decision_function(X_with_y)\n",
        "iforest_with_y_pred = get_top1_prediction(iforest_with_y_scores)\n",
        "print(f\"   ✓ Detected {iforest_with_y_pred.sum()} outlier(s)\")\n",
        "\n",
        "# 2.7. LOF with y added - take top-1\n",
        "print(\"7. LOF (with y added)...\")\n",
        "lof_with_y = LocalOutlierFactor(contamination=contamination, novelty=True)\n",
        "lof_with_y.fit(X_with_y)\n",
        "lof_with_y_scores = -lof_with_y.score_samples(X_with_y)\n",
        "lof_with_y_pred = get_top1_prediction(lof_with_y_scores)\n",
        "print(f\"   ✓ Detected {lof_with_y_pred.sum()} outlier(s)\")\n",
        "\n",
        "# ==========================================================\n",
        "# COLLECT RESULTS\n",
        "# ==========================================================\n",
        "print(\"\\n\" + \"=\"*80)\n",
        "print(\"OUTLIER DETECTION METHOD COMPARISON\")\n",
        "print(\"=\"*80)\n",
        "print(f\"True outlier count: {true_outliers.sum()}\")\n",
        "print(f\"Each method detects exactly {n_outliers_desired} outlier(s)\\n\")\n",
        "\n",
        "all_methods = {\n",
        "    **pyod_predictions,\n",
        "    'Random Forest (error)': rf_pred,\n",
        "    'Neural Network (error)': mlp_pred,\n",
        "    'Autoencoder (reconstruction)': ae_pred,\n",
        "    'Combined (RF+AE)': combined_pred,\n",
        "    'One-Class SVM (with y)': ocsvm_with_y_pred,\n",
        "    'Isolation Forest (with y)': iforest_with_y_pred,\n",
        "    'LOF (with y)': lof_with_y_pred,\n",
        "    'NNFS': nnfs_pred\n",
        "}\n",
        "\n",
        "# Collect all anomaly scores for ranking\n",
        "all_scores = {\n",
        "    **{name: scores_pyod[name] for name in detectors_pyod},\n",
        "    'Random Forest (error)': rf_errors,\n",
        "    'Neural Network (error)': mlp_errors,\n",
        "    'Autoencoder (reconstruction)': ae_errors,\n",
        "    'Combined (RF+AE)': combined_errors,\n",
        "    'One-Class SVM (with y)': ocsvm_with_y_scores,\n",
        "    'Isolation Forest (with y)': iforest_with_y_scores,\n",
        "    'LOF (with y)': lof_with_y_scores,\n",
        "    'NNFS': E_avg\n",
        "}\n",
        "\n",
        "results = []\n",
        "for name, pred in all_methods.items():\n",
        "    tp = np.sum((pred == 1) & (true_outliers == 1))\n",
        "    fp = np.sum((pred == 1) & (true_outliers == 0))\n",
        "    fn = np.sum((pred == 0) & (true_outliers == 1))\n",
        "    precision = tp / (tp + fp) if (tp + fp) > 0 else 0\n",
        "    recall = tp / (tp + fn) if (tp + fn) > 0 else 0\n",
        "    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0\n",
        "    results.append({\n",
        "        'Method': name,\n",
        "        'Precision': precision,\n",
        "        'Recall': recall,\n",
        "        'F1': f1,\n",
        "        'TP': tp,\n",
        "        'FP': fp,\n",
        "        'FN': fn,\n",
        "        'Detected': pred.sum()\n",
        "    })\n",
        "\n",
        "df_results = pd.DataFrame(results).round(3)\n",
        "df_results = df_results.sort_values('F1', ascending=False).reset_index(drop=True)\n",
        "print(\"\\n\" + df_results.to_string(index=False))\n",
        "\n",
        "# ==========================================================\n",
        "# RANK TABLE FOR THE TRUE OUTLIER\n",
        "# ==========================================================\n",
        "print(\"\\n\" + \"=\"*80)\n",
        "print(\"TRUE OUTLIER RANK IN EACH METHOD (1 = most anomalous)\")\n",
        "print(\"=\"*80)\n",
        "\n",
        "outlier_idx_in_df = outlier_idx\n",
        "rank_data = []\n",
        "\n",
        "for name in all_methods.keys():\n",
        "    if name in all_scores:\n",
        "        scores = all_scores[name]\n",
        "        if len(scores) == Q:\n",
        "            rank = np.argsort(np.argsort(-scores))[outlier_idx_in_df] + 1\n",
        "        else:\n",
        "            rank = -1\n",
        "    else:\n",
        "        rank = -1\n",
        "    rank_data.append({'Method': name, 'Rank': rank, 'Success': rank == 1})\n",
        "\n",
        "df_ranks = pd.DataFrame(rank_data).sort_values('Rank').reset_index(drop=True)\n",
        "print(df_ranks.to_string(index=False))\n",
        "\n",
        "# Summary of successful detections\n",
        "print(\"\\n\" + \"=\"*80)\n",
        "print(\"SUMMARY: METHODS THAT CORRECTLY DETECTED THE TRUE OUTLIER\")\n",
        "print(\"=\"*80)\n",
        "successful_methods = df_ranks[df_ranks['Success'] == True]['Method'].tolist()\n",
        "if successful_methods:\n",
        "    print(f\"\\n✓ {len(successful_methods)} method(s) successfully detected the true outlier as top-1:\")\n",
        "    for method in successful_methods:\n",
        "        print(f\"  • {method}\")\n",
        "else:\n",
        "    print(\"\\n✗ No method detected the true outlier as top-1\")\n",
        "\n",
        "# ==========================================================\n",
        "# NNFS ERROR VISUALIZATION\n",
        "# ==========================================================\n",
        "plt.figure(figsize=(12, 6))\n",
        "examples = np.arange(1, Q+1)\n",
        "bars = plt.bar(examples, E_avg, color='skyblue', edgecolor='black')\n",
        "# Color the detected outlier in red\n",
        "bars[nnfs_outlier_idx].set_color('red')\n",
        "# Color the true outlier in orange if different from detected\n",
        "if nnfs_outlier_idx != outlier_idx_in_df:\n",
        "    bars[outlier_idx_in_df].set_color('orange')\n",
        "    from matplotlib.patches import Patch\n",
        "    legend_elements = [Patch(facecolor='red', label='Detected outlier (NNFS)'),\n",
        "                      Patch(facecolor='orange', label='True outlier (if different)')]\n",
        "    plt.legend(handles=legend_elements)\n",
        "else:\n",
        "    from matplotlib.patches import Patch\n",
        "    legend_elements = [Patch(facecolor='red', label='Detected outlier (NNFS) = True outlier')]\n",
        "    plt.legend(handles=legend_elements)\n",
        "\n",
        "plt.xlabel('Observation number')\n",
        "plt.ylabel('Averaged squared error')\n",
        "plt.title(f'NNFS error distribution\\n(red – detected outlier, orange – true outlier if different)')\n",
        "plt.grid(axis='y', linestyle=':', alpha=0.7)\n",
        "plt.tight_layout()\n",
        "plt.show()\n",
        "\n",
        "print(\"\\n\" + \"=\"*60)\n",
        "print(\"CONCLUSIONS:\")\n",
        "print(\"=\"*60)\n",
        "print(\"✓ NNFS successfully detects the outlier because it models the relationship y = f(X)\")\n",
        "print(\"✓ Methods using prediction error can also detect the outlier\")\n",
        "print(\"✓ Autoencoder (reconstruction error) analyzes only input features and may fail to detect the outlier\")\n",
        "print(\"✓ PyOD methods (input features only) DO NOT detect the outlier\")\n",
        "print(f\"\\n✓ ALL {len(all_methods)} methods were forced to detect exactly ONE outlier\")\n",
        "print(\"=\"*60)\n",
        "print(\"TESTING COMPLETED.\")\n",
        "print(\"=\"*60)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "F4hzmnskSrfW",
        "outputId": "da0bb23a-22fa-4835-f9db-fe66ea0eca21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting pyod\n",
            "  Downloading pyod-3.5.0-py3-none-any.whl.metadata (57 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m57.3/57.3 kB\u001b[0m \u001b[31m1.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: joblib>=1.5 in /usr/local/lib/python3.12/dist-packages (from pyod) (1.5.3)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/dist-packages (from pyod) (3.10.0)\n",
            "Requirement already satisfied: numpy>=1.19 in /usr/local/lib/python3.12/dist-packages (from pyod) (2.0.2)\n",
            "Requirement already satisfied: numba>=0.51 in /usr/local/lib/python3.12/dist-packages (from pyod) (0.60.0)\n",
            "Requirement already satisfied: scipy>=1.5.1 in /usr/local/lib/python3.12/dist-packages (from pyod) (1.16.3)\n",
            "Requirement already satisfied: scikit-learn>=0.22.0 in /usr/local/lib/python3.12/dist-packages (from pyod) (1.6.1)\n",
            "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.12/dist-packages (from numba>=0.51->pyod) (0.43.0)\n",
            "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=0.22.0->pyod) (3.6.0)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->pyod) (1.3.3)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/dist-packages (from matplotlib->pyod) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib->pyod) (4.62.1)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->pyod) (1.5.0)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/dist-packages (from matplotlib->pyod) (26.1)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/dist-packages (from matplotlib->pyod) (11.3.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/dist-packages (from matplotlib->pyod) (3.3.2)\n",
            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.12/dist-packages (from matplotlib->pyod) (2.9.0.post0)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.12/dist-packages (from python-dateutil>=2.7->matplotlib->pyod) (1.17.0)\n",
            "Downloading pyod-3.5.0-py3-none-any.whl (391 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m391.1/391.1 kB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: pyod\n",
            "Successfully installed pyod-3.5.0\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "============================================================\n",
            "OUTLIER DETECTION PARAMETER SETUP\n",
            "============================================================\n",
            "The dataset contains 1 true outlier (proportion 5.0%)\n",
            "✅ ALL methods will search for exactly 1 outlier (5.00%)\n",
            "✅ Parameter Ksi = 0 (neuron search range)\n",
            "\n",
            "============================================================\n",
            "RUNNING NNFS ALGORITHM (FINDING EXACTLY ONE OUTLIER)\n",
            "============================================================\n",
            "Q = 20, N_x = 1, N_y = 1\n",
            "N_min = 3.8790, N_max = 10.0000\n",
            "Ksi = 0, N_lim = 3.8790\n",
            "Loop over $N$ from 4 to 4 inclusive\n",
            "This may take some time...\n",
            "  Completed N = 4\n",
            "\n",
            "==================================================\n",
            "NNFS RESULTS\n",
            "==================================================\n",
            "Number of detected outliers: 1 (expected 1)\n",
            "Detected outlier index: 10\n",
            "Anomaly score: 0.009583\n",
            "\n",
            "================================================================================\n",
            "METHODS ANALYZING ONLY INPUT FEATURES (PyOD)\n",
            "================================================================================\n",
            "NOTE: Each method will return exactly ONE outlier (top-1 by anomaly score)\n",
            "\n",
            "  ✓ ABOD (pyod) - detected 1 outlier(s)\n",
            "  ✓ HBOS (pyod) - detected 1 outlier(s)\n",
            "  ✓ IsolationForest (pyod) - detected 1 outlier(s)\n",
            "  ✓ kNN (pyod) - detected 1 outlier(s)\n",
            "  ✓ LOF (pyod) - detected 1 outlier(s)\n",
            "  ✓ OCSVM (pyod) - detected 1 outlier(s)\n",
            "  ✓ PCA (pyod) - detected 1 outlier(s)\n",
            "  ✓ COPOD (pyod) - detected 1 outlier(s)\n",
            "\n",
            "================================================================================\n",
            "METHODS ANALYZING INPUT FEATURES + TARGET VARIABLE\n",
            "================================================================================\n",
            "NOTE: Each method will return exactly ONE outlier (top-1 by anomaly score)\n",
            "\n",
            "1. Random Forest Regressor...\n",
            "   ✓ Detected 1 outlier(s)\n",
            "2. Neural Network Regressor...\n",
            "   ✓ Detected 1 outlier(s)\n",
            "3. Autoencoder (input feature reconstruction error)...\n",
            "    Autoencoder: epoch 50/300, loss = 0.362250\n",
            "    Autoencoder: epoch 100/300, loss = 0.163289\n",
            "    Autoencoder: epoch 150/300, loss = 0.103344\n",
            "    Autoencoder: epoch 200/300, loss = 0.069846\n",
            "    Autoencoder: epoch 250/300, loss = 0.045747\n",
            "    Autoencoder: epoch 300/300, loss = 0.029513\n",
            "   ✓ Detected 1 outlier(s)\n",
            "4. Combined method (Random Forest + Autoencoder)...\n",
            "   ✓ Detected 1 outlier(s)\n",
            "5. One-Class SVM (with y added)...\n",
            "   ✓ Detected 1 outlier(s)\n",
            "6. Isolation Forest (with y added)...\n",
            "   ✓ Detected 1 outlier(s)\n",
            "7. LOF (with y added)...\n",
            "   ✓ Detected 1 outlier(s)\n",
            "\n",
            "================================================================================\n",
            "OUTLIER DETECTION METHOD COMPARISON\n",
            "================================================================================\n",
            "True outlier count: 1\n",
            "Each method detects exactly 1 outlier(s)\n",
            "\n",
            "\n",
            "                      Method  Precision  Recall  F1  TP  FP  FN  Detected\n",
            "                        NNFS        1.0     1.0 1.0   1   0   0         1\n",
            "                 ABOD (pyod)        0.0     0.0 0.0   0   1   1         1\n",
            "      IsolationForest (pyod)        0.0     0.0 0.0   0   1   1         1\n",
            "                 HBOS (pyod)        0.0     0.0 0.0   0   1   1         1\n",
            "                  LOF (pyod)        0.0     0.0 0.0   0   1   1         1\n",
            "                OCSVM (pyod)        0.0     0.0 0.0   0   1   1         1\n",
            "                  PCA (pyod)        0.0     0.0 0.0   0   1   1         1\n",
            "                  kNN (pyod)        0.0     0.0 0.0   0   1   1         1\n",
            "                COPOD (pyod)        0.0     0.0 0.0   0   1   1         1\n",
            "       Random Forest (error)        0.0     0.0 0.0   0   1   1         1\n",
            "Autoencoder (reconstruction)        0.0     0.0 0.0   0   1   1         1\n",
            "      Neural Network (error)        0.0     0.0 0.0   0   1   1         1\n",
            "            Combined (RF+AE)        0.0     0.0 0.0   0   1   1         1\n",
            "      One-Class SVM (with y)        0.0     0.0 0.0   0   1   1         1\n",
            "   Isolation Forest (with y)        0.0     0.0 0.0   0   1   1         1\n",
            "                LOF (with y)        0.0     0.0 0.0   0   1   1         1\n",
            "\n",
            "================================================================================\n",
            "TRUE OUTLIER RANK IN EACH METHOD (1 = most anomalous)\n",
            "================================================================================\n",
            "                      Method  Rank  Success\n",
            "                        NNFS     1     True\n",
            "Autoencoder (reconstruction)     2    False\n",
            "            Combined (RF+AE)     3    False\n",
            "                LOF (with y)     5    False\n",
            "       Random Forest (error)     7    False\n",
            "                 ABOD (pyod)     8    False\n",
            "                  LOF (pyod)    10    False\n",
            "                 HBOS (pyod)    10    False\n",
            "      IsolationForest (pyod)    12    False\n",
            "      One-Class SVM (with y)    14    False\n",
            "                  kNN (pyod)    14    False\n",
            "                  PCA (pyod)    16    False\n",
            "   Isolation Forest (with y)    16    False\n",
            "                COPOD (pyod)    18    False\n",
            "                OCSVM (pyod)    20    False\n",
            "      Neural Network (error)    20    False\n",
            "\n",
            "================================================================================\n",
            "SUMMARY: METHODS THAT CORRECTLY DETECTED THE TRUE OUTLIER\n",
            "================================================================================\n",
            "\n",
            "✓ 1 method(s) successfully detected the true outlier as top-1:\n",
            "  • NNFS\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "============================================================\n",
            "CONCLUSIONS:\n",
            "============================================================\n",
            "✓ NNFS successfully detects the outlier because it models the relationship y = f(X)\n",
            "✓ Methods using prediction error can also detect the outlier\n",
            "✓ Autoencoder (reconstruction error) analyzes only input features and may fail to detect the outlier\n",
            "✓ PyOD methods (input features only) DO NOT detect the outlier\n",
            "\n",
            "✓ ALL 16 methods were forced to detect exactly ONE outlier\n",
            "============================================================\n",
            "TESTING COMPLETED.\n",
            "============================================================\n"
          ]
        }
      ]
    }
  ]
}