{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "0QB3IwmVVSBb", "outputId": "60b28048-da17-46ce-d45f-960acc750544" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Requirement already satisfied: pyod in /usr/local/lib/python3.12/dist-packages (3.5.2)\n", "Requirement already satisfied: openpyxl in /usr/local/lib/python3.12/dist-packages (3.1.5)\n", "Requirement 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: et-xmlfile in /usr/local/lib/python3.12/dist-packages (from openpyxl) (2.0.0)\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.63.0)\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.2)\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", "Experiment: 30 runs, 4 ksi values (original NNFA, 500 epochs)\n", "Now using 20 outliers (top 10 and bottom 10 replaced by (max+min)/2).\n", "\n", "--- Run 1/30, seed = 0 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.987\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.993\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.990\n", "\n", "--- Run 2/30, seed = 1 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.986\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.992\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.993\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.991\n", "\n", "--- Run 3/30, seed = 2 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.973\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.987\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 4/30, seed = 3 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.976\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.981\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.990\n", "\n", "--- Run 5/30, seed = 4 ---\n", " NNFA (ξ=0) F1 = 0.800, AUC = 0.987\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.987\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.991\n", "\n", "--- Run 6/30, seed = 5 ---\n", " NNFA (ξ=0) F1 = 0.700, AUC = 0.980\n", " NNFA (ξ=0.01) F1 = 0.700, AUC = 0.984\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.990\n", "\n", "--- Run 7/30, seed = 6 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.983\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.982\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.993\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.991\n", "\n", "--- Run 8/30, seed = 7 ---\n", " NNFA (ξ=0) F1 = 0.700, AUC = 0.962\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.990\n", "\n", "--- Run 9/30, seed = 8 ---\n", " NNFA (ξ=0) F1 = 0.700, AUC = 0.986\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.992\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.993\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.991\n", "\n", "--- Run 10/30, seed = 9 ---\n", " NNFA (ξ=0) F1 = 0.850, AUC = 0.989\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.985\n", " NNFA (ξ=0.5) F1 = 0.750, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 11/30, seed = 10 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.995\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.996\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.992\n", "\n", "--- Run 12/30, seed = 11 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.973\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.980\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 13/30, seed = 12 ---\n", " NNFA (ξ=0) F1 = 0.850, AUC = 0.986\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.987\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.991\n", "\n", "--- Run 14/30, seed = 13 ---\n", " NNFA (ξ=0) F1 = 0.800, AUC = 0.984\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.986\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 15/30, seed = 14 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.976\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.978\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 16/30, seed = 15 ---\n", " NNFA (ξ=0) F1 = 0.800, AUC = 0.995\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.993\n", " NNFA (ξ=1) F1 = 0.800, AUC = 0.991\n", "\n", "--- Run 17/30, seed = 16 ---\n", " NNFA (ξ=0) F1 = 0.800, AUC = 0.977\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.984\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 18/30, seed = 17 ---\n", " NNFA (ξ=0) F1 = 0.800, AUC = 0.993\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.988\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.800, AUC = 0.991\n", "\n", "--- Run 19/30, seed = 18 ---\n", " NNFA (ξ=0) F1 = 0.850, AUC = 0.985\n", " NNFA (ξ=0.01) F1 = 0.850, AUC = 0.995\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.991\n", "\n", "--- Run 20/30, seed = 19 ---\n", " NNFA (ξ=0) F1 = 0.700, AUC = 0.983\n", " NNFA (ξ=0.01) F1 = 0.700, AUC = 0.982\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 21/30, seed = 20 ---\n", " NNFA (ξ=0) F1 = 0.850, AUC = 0.989\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.985\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 22/30, seed = 21 ---\n", " NNFA (ξ=0) F1 = 0.650, AUC = 0.968\n", " NNFA (ξ=0.01) F1 = 0.700, AUC = 0.973\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.991\n", "\n", "--- Run 23/30, seed = 22 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.987\n", " NNFA (ξ=0.01) F1 = 0.700, AUC = 0.985\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.991\n", "\n", "--- Run 24/30, seed = 23 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.990\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.986\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.991\n", "\n", "--- Run 25/30, seed = 24 ---\n", " NNFA (ξ=0) F1 = 0.800, AUC = 0.997\n", " NNFA (ξ=0.01) F1 = 0.800, AUC = 0.996\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.991\n", "\n", "--- Run 26/30, seed = 25 ---\n", " NNFA (ξ=0) F1 = 0.700, AUC = 0.994\n", " NNFA (ξ=0.01) F1 = 0.700, AUC = 0.988\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.992\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.991\n", "\n", "--- Run 27/30, seed = 26 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.990\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.986\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.991\n", "\n", "--- Run 28/30, seed = 27 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.978\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.986\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.993\n", " NNFA (ξ=1) F1 = 0.750, AUC = 0.991\n", "\n", "--- Run 29/30, seed = 28 ---\n", " NNFA (ξ=0) F1 = 0.750, AUC = 0.989\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.979\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "--- Run 30/30, seed = 29 ---\n", " NNFA (ξ=0) F1 = 0.700, AUC = 0.979\n", " NNFA (ξ=0.01) F1 = 0.750, AUC = 0.985\n", " NNFA (ξ=0.5) F1 = 0.800, AUC = 0.991\n", " NNFA (ξ=1) F1 = 0.700, AUC = 0.990\n", "\n", "================================================================================\n", "SUMMARY TABLE (mean ± std) over 30 runs\n", "================================================================================\n", " Method F1 (mean ± std) ROC-AUC (mean ± std)\n", " NNFA (ξ=0.5) 0.798 ± 0.009 0.992 ± 0.001\n", " NNFA (ξ=1) 0.728 ± 0.031 0.991 ± 0.000\n", " NNFA (ξ=0.01) 0.760 ± 0.037 0.986 ± 0.005\n", " NNFA (ξ=0) 0.760 ± 0.051 0.984 ± 0.008\n", " Neural Network (error) 0.610 ± 0.187 0.918 ± 0.047\n", " Random Forest (error) 0.497 ± 0.050 0.853 ± 0.036\n", " Combined (RF+AE) 0.027 ± 0.042 0.824 ± 0.042\n", " LOF (pyod) 0.150 ± 0.000 0.628 ± 0.000\n", " LOF (with y) 0.000 ± 0.000 0.618 ± 0.000\n", " COPOD (pyod) 0.000 ± 0.000 0.603 ± 0.000\n", " OCSVM (pyod) 0.000 ± 0.000 0.597 ± 0.000\n", " PCA (pyod) 0.000 ± 0.000 0.571 ± 0.000\n", " IsolationForest (pyod) 0.000 ± 0.000 0.564 ± 0.023\n", "Autoencoder (reconstruction) 0.005 ± 0.015 0.553 ± 0.052\n", " kNN (pyod) 0.000 ± 0.000 0.547 ± 0.000\n", " Isolation Forest (with y) 0.000 ± 0.000 0.541 ± 0.029\n", " ABOD (pyod) 0.200 ± 0.000 0.526 ± 0.000\n", " One-Class SVM (with y) 0.012 ± 0.025 0.450 ± 0.078\n", " HBOS (pyod) 0.000 ± 0.000 0.444 ± 0.000\n", "\n", "================================================================================\n", "PAIRWISE WILCOXON P-VALUES (rounded to 4 decimals)\n", "================================================================================\n", " ABOD (pyod) HBOS (pyod) IsolationForest (pyod) kNN (pyod) LOF (pyod) OCSVM (pyod) PCA (pyod) COPOD (pyod) Random Forest (error) Neural Network (error) Autoencoder (reconstruction) Combined (RF+AE) One-Class SVM (with y) Isolation Forest (with y) LOF (with y) NNFA (ξ=0) NNFA (ξ=0.01) NNFA (ξ=0.5) NNFA (ξ=1)\n", "ABOD (pyod) 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", "HBOS (pyod) 0.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0833 0.0042 0.0196 1.0 1.0 0.0 0.0 0.0 0.0\n", "IsolationForest (pyod) 0.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0833 0.0042 0.0196 1.0 1.0 0.0 0.0 0.0 0.0\n", "kNN (pyod) 0.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0833 0.0042 0.0196 1.0 1.0 0.0 0.0 0.0 0.0\n", "LOF (pyod) 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", "OCSVM (pyod) 0.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0833 0.0042 0.0196 1.0 1.0 0.0 0.0 0.0 0.0\n", "PCA (pyod) 0.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0833 0.0042 0.0196 1.0 1.0 0.0 0.0 0.0 0.0\n", "COPOD (pyod) 0.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0833 0.0042 0.0196 1.0 1.0 0.0 0.0 0.0 0.0\n", "Random Forest (error) 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0042 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0\n", "Neural Network (error) 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0042 1.0 0.0 0.0 0.0 0.0 0.0 0.0005 0.0003 0.0 0.0033\n", "Autoencoder (reconstruction) 0.0 0.0833 0.0833 0.0833 0.0 0.0833 0.0833 0.0833 0.0 0.0 1.0 0.0059 0.1573 0.0833 0.0833 0.0 0.0 0.0 0.0\n", "Combined (RF+AE) 0.0 0.0042 0.0042 0.0042 0.0 0.0042 0.0042 0.0042 0.0 0.0 0.0059 1.0 0.0832 0.0042 0.0042 0.0 0.0 0.0 0.0\n", "One-Class SVM (with y) 0.0 0.0196 0.0196 0.0196 0.0 0.0196 0.0196 0.0196 0.0 0.0 0.1573 0.0832 1.0 0.0196 0.0196 0.0 0.0 0.0 0.0\n", "Isolation Forest (with y) 0.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0833 0.0042 0.0196 1.0 1.0 0.0 0.0 0.0 0.0\n", "LOF (with y) 0.0 1.0 1.0 1.0 0.0 1.0 1.0 1.0 0.0 0.0 0.0833 0.0042 0.0196 1.0 1.0 0.0 0.0 0.0 0.0\n", "NNFA (ξ=0) 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0005 0.0 0.0 0.0 0.0 0.0 1.0 0.7589 0.0002 0.0091\n", "NNFA (ξ=0.01) 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0003 0.0 0.0 0.0 0.0 0.0 0.7589 1.0 0.0001 0.0031\n", "NNFA (ξ=0.5) 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0002 0.0001 1.0 0.0\n", "NNFA (ξ=1) 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0033 0.0 0.0 0.0 0.0 0.0 0.0091 0.0031 0.0 1.0\n", "\n", "Full pairwise p-value matrix saved to 'pairwise_wilcoxon_matrix.csv'\n", "\n", "================================================================================\n", "DETAILED SIGNIFICANT DIFFERENCES (p < 0.05)\n", "================================================================================\n", "ABOD (pyod) vs HBOS (pyod): p = 0.000000\n", "ABOD (pyod) vs IsolationForest (pyod): p = 0.000000\n", "ABOD (pyod) vs kNN (pyod): p = 0.000000\n", "ABOD (pyod) vs LOF (pyod): p = 0.000000\n", "ABOD (pyod) vs OCSVM (pyod): p = 0.000000\n", "ABOD (pyod) vs PCA (pyod): p = 0.000000\n", "ABOD (pyod) vs COPOD (pyod): p = 0.000000\n", "ABOD (pyod) vs Random Forest (error): p = 0.000001\n", "ABOD (pyod) vs Neural Network (error): p = 0.000002\n", "ABOD (pyod) vs Autoencoder (reconstruction): p = 0.000000\n", "ABOD (pyod) vs Combined (RF+AE): p = 0.000001\n", "ABOD (pyod) vs One-Class SVM (with y): p = 0.000000\n", "ABOD (pyod) vs Isolation Forest (with y): p = 0.000000\n", "ABOD (pyod) vs LOF (with y): p = 0.000000\n", "ABOD (pyod) vs NNFA (ξ=0): p = 0.000001\n", "ABOD (pyod) vs NNFA (ξ=0.01): p = 0.000001\n", "ABOD (pyod) vs NNFA (ξ=0.5): p = 0.000000\n", "ABOD (pyod) vs NNFA (ξ=1): p = 0.000001\n", "HBOS (pyod) vs LOF (pyod): p = 0.000000\n", "HBOS (pyod) vs Random Forest (error): p = 0.000001\n", "HBOS (pyod) vs Neural Network (error): p = 0.000002\n", "HBOS (pyod) vs Combined (RF+AE): p = 0.004246\n", "HBOS (pyod) vs One-Class SVM (with y): p = 0.019631\n", "HBOS (pyod) vs NNFA (ξ=0): p = 0.000001\n", "HBOS (pyod) vs NNFA (ξ=0.01): p = 0.000001\n", "HBOS (pyod) vs NNFA (ξ=0.5): p = 0.000000\n", "HBOS (pyod) vs NNFA (ξ=1): p = 0.000001\n", "IsolationForest (pyod) vs LOF (pyod): p = 0.000000\n", "IsolationForest (pyod) vs Random Forest (error): p = 0.000001\n", "IsolationForest (pyod) vs Neural Network (error): p = 0.000002\n", "IsolationForest (pyod) vs Combined (RF+AE): p = 0.004246\n", "IsolationForest (pyod) vs One-Class SVM (with y): p = 0.019631\n", "IsolationForest (pyod) vs NNFA (ξ=0): p = 0.000001\n", "IsolationForest (pyod) vs NNFA (ξ=0.01): p = 0.000001\n", "IsolationForest (pyod) vs NNFA (ξ=0.5): p = 0.000000\n", "IsolationForest (pyod) vs NNFA (ξ=1): p = 0.000001\n", "kNN (pyod) vs LOF (pyod): p = 0.000000\n", "kNN (pyod) vs Random Forest (error): p = 0.000001\n", "kNN (pyod) vs Neural Network (error): p = 0.000002\n", "kNN (pyod) vs Combined (RF+AE): p = 0.004246\n", "kNN (pyod) vs One-Class SVM (with y): p = 0.019631\n", "kNN (pyod) vs NNFA (ξ=0): p = 0.000001\n", "kNN (pyod) vs NNFA (ξ=0.01): p = 0.000001\n", "kNN (pyod) vs NNFA (ξ=0.5): p = 0.000000\n", "kNN (pyod) vs NNFA (ξ=1): p = 0.000001\n", "LOF (pyod) vs OCSVM (pyod): p = 0.000000\n", "LOF (pyod) vs PCA (pyod): p = 0.000000\n", "LOF (pyod) vs COPOD (pyod): p = 0.000000\n", "LOF (pyod) vs Random Forest (error): p = 0.000001\n", "LOF (pyod) vs Neural Network (error): p = 0.000002\n", "LOF (pyod) vs Autoencoder (reconstruction): p = 0.000000\n", "LOF (pyod) vs Combined (RF+AE): p = 0.000001\n", "LOF (pyod) vs One-Class SVM (with y): p = 0.000000\n", "LOF (pyod) vs Isolation Forest (with y): p = 0.000000\n", "LOF (pyod) vs LOF (with y): p = 0.000000\n", "LOF (pyod) vs NNFA (ξ=0): p = 0.000001\n", "LOF (pyod) vs NNFA (ξ=0.01): p = 0.000001\n", "LOF (pyod) vs NNFA (ξ=0.5): p = 0.000000\n", "LOF (pyod) vs NNFA (ξ=1): p = 0.000001\n", "OCSVM (pyod) vs Random Forest (error): p = 0.000001\n", "OCSVM (pyod) vs Neural Network (error): p = 0.000002\n", "OCSVM (pyod) vs Combined (RF+AE): p = 0.004246\n", "OCSVM (pyod) vs One-Class SVM (with y): p = 0.019631\n", "OCSVM (pyod) vs NNFA (ξ=0): p = 0.000001\n", "OCSVM (pyod) vs NNFA (ξ=0.01): p = 0.000001\n", "OCSVM (pyod) vs NNFA (ξ=0.5): p = 0.000000\n", "OCSVM (pyod) vs NNFA (ξ=1): p = 0.000001\n", "PCA (pyod) vs Random Forest (error): p = 0.000001\n", "PCA (pyod) vs Neural Network (error): p = 0.000002\n", "PCA (pyod) vs Combined (RF+AE): p = 0.004246\n", "PCA (pyod) vs One-Class SVM (with y): p = 0.019631\n", "PCA (pyod) vs NNFA (ξ=0): p = 0.000001\n", "PCA (pyod) vs NNFA (ξ=0.01): p = 0.000001\n", "PCA (pyod) vs NNFA (ξ=0.5): p = 0.000000\n", "PCA (pyod) vs NNFA (ξ=1): p = 0.000001\n", "COPOD (pyod) vs Random Forest (error): p = 0.000001\n", "COPOD (pyod) vs Neural Network (error): p = 0.000002\n", "COPOD (pyod) vs Combined (RF+AE): p = 0.004246\n", "COPOD (pyod) vs One-Class SVM (with y): p = 0.019631\n", "COPOD (pyod) vs NNFA (ξ=0): p = 0.000001\n", "COPOD (pyod) vs NNFA (ξ=0.01): p = 0.000001\n", "COPOD (pyod) vs NNFA (ξ=0.5): p = 0.000000\n", "COPOD (pyod) vs NNFA (ξ=1): p = 0.000001\n", "Random Forest (error) vs Neural Network (error): p = 0.004235\n", "Random Forest (error) vs Autoencoder (reconstruction): p = 0.000001\n", "Random Forest (error) vs Combined (RF+AE): p = 0.000001\n", "Random Forest (error) vs One-Class SVM (with y): p = 0.000001\n", "Random Forest (error) vs Isolation Forest (with y): p = 0.000001\n", "Random Forest (error) vs LOF (with y): p = 0.000001\n", "Random Forest (error) vs NNFA (ξ=0): p = 0.000002\n", "Random Forest (error) vs NNFA (ξ=0.01): p = 0.000002\n", "Random Forest (error) vs NNFA (ξ=0.5): p = 0.000001\n", "Random Forest (error) vs NNFA (ξ=1): p = 0.000001\n", "Neural Network (error) vs Autoencoder (reconstruction): p = 0.000002\n", "Neural Network (error) vs Combined (RF+AE): p = 0.000002\n", "Neural Network (error) vs One-Class SVM (with y): p = 0.000002\n", "Neural Network (error) vs Isolation Forest (with y): p = 0.000002\n", "Neural Network (error) vs LOF (with y): p = 0.000002\n", "Neural Network (error) vs NNFA (ξ=0): p = 0.000462\n", "Neural Network (error) vs NNFA (ξ=0.01): p = 0.000321\n", "Neural Network (error) vs NNFA (ξ=0.5): p = 0.000020\n", "Neural Network (error) vs NNFA (ξ=1): p = 0.003342\n", "Autoencoder (reconstruction) vs Combined (RF+AE): p = 0.005888\n", "Autoencoder (reconstruction) vs NNFA (ξ=0): p = 0.000001\n", "Autoencoder (reconstruction) vs NNFA (ξ=0.01): p = 0.000001\n", "Autoencoder (reconstruction) vs NNFA (ξ=0.5): p = 0.000000\n", "Autoencoder (reconstruction) vs NNFA (ξ=1): p = 0.000001\n", "Combined (RF+AE) vs Isolation Forest (with y): p = 0.004246\n", "Combined (RF+AE) vs LOF (with y): p = 0.004246\n", "Combined (RF+AE) vs NNFA (ξ=0): p = 0.000001\n", "Combined (RF+AE) vs NNFA (ξ=0.01): p = 0.000001\n", "Combined (RF+AE) vs NNFA (ξ=0.5): p = 0.000001\n", "Combined (RF+AE) vs NNFA (ξ=1): p = 0.000001\n", "One-Class SVM (with y) vs Isolation Forest (with y): p = 0.019631\n", "One-Class SVM (with y) vs LOF (with y): p = 0.019631\n", "One-Class SVM (with y) vs NNFA (ξ=0): p = 0.000001\n", "One-Class SVM (with y) vs NNFA (ξ=0.01): p = 0.000001\n", "One-Class SVM (with y) vs NNFA (ξ=0.5): p = 0.000000\n", "One-Class SVM (with y) vs NNFA (ξ=1): p = 0.000001\n", "Isolation Forest (with y) vs NNFA (ξ=0): p = 0.000001\n", "Isolation Forest (with y) vs NNFA (ξ=0.01): p = 0.000001\n", "Isolation Forest (with y) vs NNFA (ξ=0.5): p = 0.000000\n", "Isolation Forest (with y) vs NNFA (ξ=1): p = 0.000001\n", "LOF (with y) vs NNFA (ξ=0): p = 0.000001\n", "LOF (with y) vs NNFA (ξ=0.01): p = 0.000001\n", "LOF (with y) vs NNFA (ξ=0.5): p = 0.000000\n", "LOF (with y) vs NNFA (ξ=1): p = 0.000001\n", "NNFA (ξ=0) vs NNFA (ξ=0.5): p = 0.000211\n", "NNFA (ξ=0) vs NNFA (ξ=1): p = 0.009063\n", "NNFA (ξ=0.01) vs NNFA (ξ=0.5): p = 0.000077\n", "NNFA (ξ=0.01) vs NNFA (ξ=1): p = 0.003090\n", "NNFA (ξ=0.5) vs NNFA (ξ=1): p = 0.000002\n", "\n", "Results saved to 'table5_all_ksi_results.xlsx'\n", "\n", "================================================================================\n", "STATISTICAL SIGNIFICANCE (Wilcoxon test, two-sided, for F1)\n", "================================================================================\n", "NNFA (ξ=0) vs Neural Network (error): p = 0.000462 -> significant (p<0.05)\n", "NNFA (ξ=0.01) vs Neural Network (error): p = 0.000321 -> significant (p<0.05)\n", "NNFA (ξ=0.5) vs Neural Network (error): p = 0.000020 -> significant (p<0.05)\n", "NNFA (ξ=1) vs Neural Network (error): p = 0.003342 -> significant (p<0.05)\n", "\n", "NNFA (ξ=0) vs NNFA (ξ=1): p = 0.009063 -> significant\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "application/javascript": [ "\n", " async function download(id, filename, size) {\n", " if (!google.colab.kernel.accessAllowed) {\n", " return;\n", " }\n", " const div = document.createElement('div');\n", " const label = document.createElement('label');\n", " label.textContent = `Downloading \"${filename}\": `;\n", " div.appendChild(label);\n", " const progress = document.createElement('progress');\n", " progress.max = size;\n", " div.appendChild(progress);\n", " document.body.appendChild(div);\n", "\n", " const buffers = [];\n", " let downloaded = 0;\n", "\n", " const channel = await google.colab.kernel.comms.open(id);\n", " // Send a message to notify the kernel that we're ready.\n", " channel.send({})\n", "\n", " for await (const message of channel.messages) {\n", " // Send a message to notify the kernel that we're ready.\n", " channel.send({})\n", " if (message.buffers) {\n", " for (const buffer of message.buffers) {\n", " buffers.push(buffer);\n", " downloaded += buffer.byteLength;\n", " progress.value = downloaded;\n", " }\n", " }\n", " }\n", " const blob = new Blob(buffers, {type: 'application/binary'});\n", " const a = document.createElement('a');\n", " a.href = window.URL.createObjectURL(blob);\n", " a.download = filename;\n", " div.appendChild(a);\n", " a.click();\n", " div.remove();\n", " }\n", " " ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "application/javascript": [ "download(\"download_bc4a395e-ad80-40ff-abca-5b4bcd5783a3\", \"table5_all_ksi_results.xlsx\", 8339)" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "application/javascript": [ "\n", " async function download(id, filename, size) {\n", " if (!google.colab.kernel.accessAllowed) {\n", " return;\n", " }\n", " const div = document.createElement('div');\n", " const label = document.createElement('label');\n", " label.textContent = `Downloading \"${filename}\": `;\n", " div.appendChild(label);\n", " const progress = document.createElement('progress');\n", " progress.max = size;\n", " div.appendChild(progress);\n", " document.body.appendChild(div);\n", "\n", " const buffers = [];\n", " let downloaded = 0;\n", "\n", " const channel = await google.colab.kernel.comms.open(id);\n", " // Send a message to notify the kernel that we're ready.\n", " channel.send({})\n", "\n", " for await (const message of channel.messages) {\n", " // Send a message to notify the kernel that we're ready.\n", " channel.send({})\n", " if (message.buffers) {\n", " for (const buffer of message.buffers) {\n", " buffers.push(buffer);\n", " downloaded += buffer.byteLength;\n", " progress.value = downloaded;\n", " }\n", " }\n", " }\n", " const blob = new Blob(buffers, {type: 'application/binary'});\n", " const a = document.createElement('a');\n", " a.href = window.URL.createObjectURL(blob);\n", " a.download = filename;\n", " div.appendChild(a);\n", " a.click();\n", " div.remove();\n", " }\n", " " ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "application/javascript": [ "download(\"download_ea0ec67e-f512-483f-add7-e1c0ec521b07\", \"pairwise_wilcoxon_matrix.csv\", 7223)" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Files downloaded automatically.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "import sys\n", "!{sys.executable} -m pip install pyod openpyxl\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 random\n", "import matplotlib.pyplot as plt\n", "from sklearn.preprocessing import StandardScaler\n", "from scipy.stats import wilcoxon\n", "from sklearn.metrics import roc_auc_score\n", "import warnings\n", "warnings.filterwarnings('ignore')\n", "\n", "from pyod.models import abod, hbos, iforest, knn, lof, ocsvm, pca, copod\n", "from sklearn.ensemble import IsolationForest as SklearnIForest\n", "from sklearn.svm import OneClassSVM\n", "from sklearn.neighbors import LocalOutlierFactor\n", "from sklearn.ensemble import RandomForestRegressor\n", "from sklearn.neural_network import MLPRegressor\n", "\n", "# ------------------------------------------------------------\n", "# 1. Dataset creation (Concrete Strength with 20 outliers)\n", "# ------------------------------------------------------------\n", "def create_concrete_dataset(seed_shuffle):\n", " url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/concrete/compressive/Concrete_Data.xls\"\n", " df = pd.read_excel(url)\n", " df.columns = [\n", " 'Cement', 'BlastFurnaceSlag', 'FlyAsh', 'Water',\n", " 'Superplasticizer', 'CoarseAggregate', 'FineAggregate',\n", " 'Age', 'CompressiveStrength'\n", " ]\n", " # 1. Находим максимальное и минимальное значение прочности\n", " Smax = df['CompressiveStrength'].max()\n", " Smin = df['CompressiveStrength'].min()\n", " Savg = (Smax + Smin) / 2\n", "\n", " # 2. Сортируем по убыванию прочности\n", " df_sorted = df.sort_values('CompressiveStrength', ascending=False).reset_index(drop=True)\n", " n_outliers_per_group = 10\n", " outlier_indices = []\n", "\n", " # Заменяем первые 10 наблюдений (наибольшая прочность) на Savg\n", " for i in range(n_outliers_per_group):\n", " df_sorted.loc[i, 'CompressiveStrength'] = Savg\n", " outlier_indices.append(i)\n", " # Заменяем последние 10 наблюдений (наименьшая прочность) на Savg\n", " last_n_start = len(df_sorted) - n_outliers_per_group\n", " for i in range(last_n_start, len(df_sorted)):\n", " df_sorted.loc[i, 'CompressiveStrength'] = Savg\n", " outlier_indices.append(i)\n", "\n", " # 3. Присваиваем статус выброса\n", " df_sorted['is_outlier'] = 0\n", " df_sorted.loc[outlier_indices, 'is_outlier'] = 1\n", "\n", " # 4. Перемешиваем данные\n", " df_shuffled = df_sorted.sample(frac=1, random_state=seed_shuffle).reset_index(drop=True)\n", " X = df_shuffled.drop(['CompressiveStrength', 'is_outlier'], axis=1).values.astype(np.float32)\n", " y = df_shuffled['CompressiveStrength'].values.astype(np.float32).reshape(-1, 1)\n", " true_outliers = df_shuffled['is_outlier'].values.astype(int)\n", "\n", " return X, y, true_outliers\n", "\n", "# ------------------------------------------------------------\n", "# 2. Helper: top‑K outliers\n", "# ------------------------------------------------------------\n", "def get_top_k_outliers(scores, k):\n", " idx = np.argsort(scores)[-k:]\n", " pred = np.zeros(len(scores), dtype=int)\n", " pred[idx] = 1\n", " return pred\n", "\n", "# ------------------------------------------------------------\n", "# 3. NNFA algorithm – возвращает (pred, scores)\n", "# ------------------------------------------------------------\n", "def run_nnfa_original(X, y, n_outliers_desired, ksi, random_state):\n", " torch.manual_seed(random_state)\n", " np.random.seed(random_state)\n", " random.seed(random_state)\n", "\n", " Q, N_x = X.shape[0], X.shape[1]\n", " N_y = 1\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, range_val\n", "\n", " X_scaled, _, _ = scale_to_minus1_1(X)\n", " y_scaled, _, _ = scale_to_minus1_1(y)\n", " X_tensor = torch.tensor(X_scaled, dtype=torch.float32)\n", " y_tensor = torch.tensor(y_scaled, dtype=torch.float32)\n", "\n", " log2q = math.log2(Q)\n", " N_min = (N_y * Q) / ((1 + log2q) * (N_x + N_y)) + 1\n", " N_max = (N_y / (N_x + N_y)) * ((Q / N_x + 1) * (N_x + N_y + 1) + 1) - 1\n", " if N_max > Q:\n", " N_max = min(Q // 2, 20)\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", " error_matrix = []\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", " model.train()\n", " for epoch in range(500):\n", " optimizer.zero_grad()\n", " outputs = model(X_tensor)\n", " loss = criterion(outputs, y_tensor)\n", " loss.backward()\n", " optimizer.step()\n", " model.eval()\n", " with torch.no_grad():\n", " predictions = model(X_tensor).numpy().flatten()\n", " errors = (predictions - y_scaled.flatten()) ** 2\n", " error_matrix.append(errors)\n", "\n", " error_matrix = np.array(error_matrix)\n", " scores = np.mean(error_matrix, axis=0) # оценка аномальности\n", " pred = get_top_k_outliers(scores, n_outliers_desired)\n", " return pred, scores\n", "\n", "# ------------------------------------------------------------\n", "# 4. Wrappers for standard methods – возвращают (pred, scores)\n", "# ------------------------------------------------------------\n", "def run_pyod_detector(model, X_scaled, n_outliers):\n", " model.fit(X_scaled)\n", " scores = model.decision_scores_\n", " pred = get_top_k_outliers(scores, n_outliers)\n", " return pred, scores\n", "\n", "def run_random_forest(X, y, n_outliers, rs):\n", " rf = RandomForestRegressor(n_estimators=100, random_state=rs)\n", " rf.fit(X, y.ravel())\n", " scores = (rf.predict(X) - y.ravel()) ** 2\n", " pred = get_top_k_outliers(scores, n_outliers)\n", " return pred, scores\n", "\n", "def run_neural_network(X, y, n_outliers, rs):\n", " mlp = MLPRegressor(hidden_layer_sizes=(20, 10), random_state=rs, max_iter=500)\n", " mlp.fit(X, y.ravel())\n", " scores = (mlp.predict(X) - y.ravel()) ** 2\n", " pred = get_top_k_outliers(scores, n_outliers)\n", " return pred, scores\n", "\n", "def run_autoencoder(X_scaled, n_outliers, rs):\n", " torch.manual_seed(rs)\n", " np.random.seed(rs)\n", " random.seed(rs)\n", " input_dim = X_scaled.shape[1]\n", " class AE(nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", " self.encoder = nn.Sequential(nn.Linear(input_dim, 16), nn.ReLU(), nn.Linear(16, 4))\n", " self.decoder = nn.Sequential(nn.Linear(4, 16), nn.ReLU(), nn.Linear(16, input_dim))\n", " def forward(self, x):\n", " return self.decoder(self.encoder(x))\n", " ae = AE()\n", " optimizer = optim.Adam(ae.parameters(), lr=0.01)\n", " criterion = nn.MSELoss()\n", " X_tensor = torch.tensor(X_scaled, dtype=torch.float32)\n", " ae.train()\n", " for _ in range(300):\n", " optimizer.zero_grad()\n", " loss = criterion(ae(X_tensor), X_tensor)\n", " loss.backward()\n", " optimizer.step()\n", " ae.eval()\n", " with torch.no_grad():\n", " recon = ae(X_tensor).numpy()\n", " scores = np.mean((recon - X_scaled) ** 2, axis=1)\n", " pred = get_top_k_outliers(scores, n_outliers)\n", " return pred, scores\n", "\n", "def run_combined_rf_ae(X, y, X_scaled, n_outliers, rs):\n", " rf = RandomForestRegressor(n_estimators=100, random_state=rs)\n", " rf.fit(X, y.ravel())\n", " rf_err = (rf.predict(X) - y.ravel()) ** 2\n", " torch.manual_seed(rs)\n", " np.random.seed(rs)\n", " random.seed(rs)\n", " input_dim = X_scaled.shape[1]\n", " class AE(nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", " self.encoder = nn.Sequential(nn.Linear(input_dim, 16), nn.ReLU(), nn.Linear(16, 4))\n", " self.decoder = nn.Sequential(nn.Linear(4, 16), nn.ReLU(), nn.Linear(16, input_dim))\n", " def forward(self, x):\n", " return self.decoder(self.encoder(x))\n", " ae = AE()\n", " optimizer = optim.Adam(ae.parameters(), lr=0.01)\n", " criterion = nn.MSELoss()\n", " X_tensor = torch.tensor(X_scaled, dtype=torch.float32)\n", " for _ in range(300):\n", " optimizer.zero_grad()\n", " loss = criterion(ae(X_tensor), X_tensor)\n", " loss.backward()\n", " optimizer.step()\n", " ae.eval()\n", " with torch.no_grad():\n", " ae_err = np.mean((ae(X_tensor).numpy() - X_scaled) ** 2, axis=1)\n", " scores = (rf_err / np.max(rf_err) + ae_err / np.max(ae_err)) / 2\n", " pred = get_top_k_outliers(scores, n_outliers)\n", " return pred, scores\n", "\n", "def run_oneclass_svm_with_y(X, y, n_outliers):\n", " Xy = np.column_stack((X, y.ravel()))\n", " model = OneClassSVM(kernel='rbf', gamma='auto')\n", " model.fit(Xy)\n", " scores = -model.decision_function(Xy)\n", " scores = np.nan_to_num(scores, nan=0.0, posinf=1.0, neginf=0.0)\n", " pred = get_top_k_outliers(scores, n_outliers)\n", " return pred, scores\n", "\n", "def run_iforest_with_y(X, y, n_outliers, rs):\n", " Xy = np.column_stack((X, y.ravel()))\n", " model = SklearnIForest(random_state=rs)\n", " model.fit(Xy)\n", " scores = -model.decision_function(Xy)\n", " scores = np.nan_to_num(scores, nan=0.0, posinf=1.0, neginf=0.0)\n", " pred = get_top_k_outliers(scores, n_outliers)\n", " return pred, scores\n", "\n", "def run_lof_with_y(X, y, n_outliers):\n", " Xy = np.column_stack((X, y.ravel()))\n", " model = LocalOutlierFactor(novelty=True)\n", " model.fit(Xy)\n", " scores = -model.score_samples(Xy)\n", " scores = np.nan_to_num(scores, nan=0.0, posinf=1.0, neginf=0.0)\n", " pred = get_top_k_outliers(scores, n_outliers)\n", " return pred, scores\n", "\n", "# ------------------------------------------------------------\n", "# 5. Main experiment\n", "# ------------------------------------------------------------\n", "n_runs = 30 # количество прогонов\n", "n_outliers = 20 # теперь 20 выбросов (top-20)\n", "ksi_values = [0, 0.01, 0.5, 1]\n", "\n", "standard_methods = [\n", " 'ABOD (pyod)', 'HBOS (pyod)', 'IsolationForest (pyod)', 'kNN (pyod)',\n", " 'LOF (pyod)', 'OCSVM (pyod)', 'PCA (pyod)', 'COPOD (pyod)',\n", " 'Random Forest (error)', 'Neural Network (error)', 'Autoencoder (reconstruction)',\n", " 'Combined (RF+AE)', 'One-Class SVM (with y)', 'Isolation Forest (with y)',\n", " 'LOF (with y)'\n", "]\n", "nnfa_methods = [f'NNFA (ξ={ksi})' for ksi in ksi_values]\n", "all_methods = standard_methods + nnfa_methods\n", "\n", "metrics = {method: {'f1': [], 'auc': []} for method in all_methods}\n", "\n", "print(f\"Experiment: {n_runs} runs, 4 ksi values (original NNFA, 500 epochs)\")\n", "print(f\"Now using 20 outliers (top 10 and bottom 10 replaced by (max+min)/2).\")\n", "for run_idx in range(n_runs):\n", " seed = run_idx\n", " print(f\"\\n--- Run {run_idx+1}/{n_runs}, seed = {seed} ---\")\n", "\n", " X, y, true_outliers = create_concrete_dataset(seed_shuffle=seed)\n", " scaler = StandardScaler()\n", " X_scaled = scaler.fit_transform(X)\n", "\n", " # ---- Standard methods ----\n", " pred_abod, scores_abod = run_pyod_detector(abod.ABOD(), X_scaled, n_outliers)\n", " pred_hbos, scores_hbos = run_pyod_detector(hbos.HBOS(), X_scaled, n_outliers)\n", " pred_knn, scores_knn = run_pyod_detector(knn.KNN(), X_scaled, n_outliers)\n", " pred_lof, scores_lof = run_pyod_detector(lof.LOF(), X_scaled, n_outliers)\n", " pred_ocsvm, scores_ocsvm = run_pyod_detector(ocsvm.OCSVM(), X_scaled, n_outliers)\n", " pred_pca, scores_pca = run_pyod_detector(pca.PCA(), X_scaled, n_outliers)\n", " pred_copod, scores_copod = run_pyod_detector(copod.COPOD(), X_scaled, n_outliers)\n", " iforest_model = iforest.IForest(random_state=seed)\n", " pred_iforest, scores_iforest = run_pyod_detector(iforest_model, X_scaled, n_outliers)\n", "\n", " pred_rf, scores_rf = run_random_forest(X, y, n_outliers, rs=seed)\n", " pred_nn, scores_nn = run_neural_network(X, y, n_outliers, rs=seed)\n", " pred_ae, scores_ae = run_autoencoder(X_scaled, n_outliers, rs=seed)\n", " pred_combined, scores_combined = run_combined_rf_ae(X, y, X_scaled, n_outliers, rs=seed)\n", " pred_ocsvm_y, scores_ocsvm_y = run_oneclass_svm_with_y(X, y, n_outliers)\n", " pred_iforest_y, scores_iforest_y = run_iforest_with_y(X, y, n_outliers, rs=seed)\n", " pred_lof_y, scores_lof_y = run_lof_with_y(X, y, n_outliers)\n", "\n", " # ---- NNFA ----\n", " nnfa_results = {}\n", " for ksi in ksi_values:\n", " pred, scores = run_nnfa_original(X, y, n_outliers, ksi=ksi, random_state=seed)\n", " nnfa_results[f'NNFA (ξ={ksi})'] = (pred, scores)\n", "\n", " all_data = {\n", " 'ABOD (pyod)': (pred_abod, scores_abod),\n", " 'HBOS (pyod)': (pred_hbos, scores_hbos),\n", " 'IsolationForest (pyod)': (pred_iforest, scores_iforest),\n", " 'kNN (pyod)': (pred_knn, scores_knn),\n", " 'LOF (pyod)': (pred_lof, scores_lof),\n", " 'OCSVM (pyod)': (pred_ocsvm, scores_ocsvm),\n", " 'PCA (pyod)': (pred_pca, scores_pca),\n", " 'COPOD (pyod)': (pred_copod, scores_copod),\n", " 'Random Forest (error)': (pred_rf, scores_rf),\n", " 'Neural Network (error)': (pred_nn, scores_nn),\n", " 'Autoencoder (reconstruction)': (pred_ae, scores_ae),\n", " 'Combined (RF+AE)': (pred_combined, scores_combined),\n", " 'One-Class SVM (with y)': (pred_ocsvm_y, scores_ocsvm_y),\n", " 'Isolation Forest (with y)': (pred_iforest_y, scores_iforest_y),\n", " 'LOF (with y)': (pred_lof_y, scores_lof_y),\n", " **nnfa_results\n", " }\n", "\n", " for method, (pred, scores) in all_data.items():\n", " scores = np.nan_to_num(scores, nan=0.0, posinf=1.0, neginf=0.0)\n", " if len(np.unique(scores)) == 1:\n", " auc = 0.5\n", " else:\n", " auc = roc_auc_score(true_outliers, scores)\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.0\n", " recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0\n", " f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0\n", " metrics[method]['f1'].append(f1)\n", " metrics[method]['auc'].append(auc)\n", "\n", " for ksi in ksi_values:\n", " name = f'NNFA (ξ={ksi})'\n", " print(f\" {name} F1 = {metrics[name]['f1'][-1]:.3f}, AUC = {metrics[name]['auc'][-1]:.3f}\")\n", "\n", "# ------------------------------------------------------------\n", "# 6. Summary table\n", "# ------------------------------------------------------------\n", "summary_rows = []\n", "for method in all_methods:\n", " f1_mean = np.mean(metrics[method]['f1'])\n", " f1_std = np.std(metrics[method]['f1'])\n", " auc_mean = np.mean(metrics[method]['auc'])\n", " auc_std = np.std(metrics[method]['auc'])\n", " summary_rows.append({\n", " 'Method': method,\n", " 'F1 (mean ± std)': f\"{f1_mean:.3f} ± {f1_std:.3f}\",\n", " 'ROC-AUC (mean ± std)': f\"{auc_mean:.3f} ± {auc_std:.3f}\"\n", " })\n", "df_summary = pd.DataFrame(summary_rows)\n", "df_summary = df_summary.sort_values('ROC-AUC (mean ± std)', ascending=False).reset_index(drop=True)\n", "\n", "print(\"\\n\" + \"=\"*80)\n", "print(f\"SUMMARY TABLE (mean ± std) over {n_runs} runs\")\n", "print(\"=\"*80)\n", "print(df_summary.to_string(index=False))\n", "\n", "# ------------------------------------------------------------\n", "# 7. Wilcoxon\n", "# ------------------------------------------------------------\n", "p_matrix = pd.DataFrame(index=all_methods, columns=all_methods, dtype=float)\n", "for i, m1 in enumerate(all_methods):\n", " for j, m2 in enumerate(all_methods):\n", " if i == j:\n", " p_matrix.loc[m1, m2] = 1.0\n", " else:\n", " if np.all(np.array(metrics[m1]['f1']) == np.array(metrics[m2]['f1'])):\n", " p = 1.0\n", " else:\n", " _, p = wilcoxon(metrics[m1]['f1'], metrics[m2]['f1'])\n", " p_matrix.loc[m1, m2] = p\n", "\n", "print(\"\\n\" + \"=\"*80)\n", "print(\"PAIRWISE WILCOXON P-VALUES (rounded to 4 decimals)\")\n", "print(\"=\"*80)\n", "p_display = p_matrix.round(4).astype(str)\n", "print(p_display.to_string())\n", "p_matrix.to_csv(\"pairwise_wilcoxon_matrix.csv\")\n", "print(\"\\nFull pairwise p-value matrix saved to 'pairwise_wilcoxon_matrix.csv'\")\n", "\n", "# ------------------------------------------------------------\n", "# 8. Significant differences\n", "# ------------------------------------------------------------\n", "print(\"\\n\" + \"=\"*80)\n", "print(\"DETAILED SIGNIFICANT DIFFERENCES (p < 0.05)\")\n", "print(\"=\"*80)\n", "significant_pairs = []\n", "for i, m1 in enumerate(all_methods):\n", " for j, m2 in enumerate(all_methods):\n", " if i < j:\n", " p_val = p_matrix.loc[m1, m2]\n", " if p_val < 0.05:\n", " significant_pairs.append((m1, m2, p_val))\n", " print(f\"{m1} vs {m2}: p = {p_val:.6f}\")\n", "if not significant_pairs:\n", " print(\"No significant differences found (p >= 0.05 for all pairs).\")\n", "\n", "# ------------------------------------------------------------\n", "# 9. Save Excel\n", "# ------------------------------------------------------------\n", "output_file = \"table5_all_ksi_results.xlsx\"\n", "with pd.ExcelWriter(output_file, engine='openpyxl') as writer:\n", " df_summary.to_excel(writer, sheet_name='summary', index=False)\n", " p_matrix.to_excel(writer, sheet_name='pairwise_wilcoxon')\n", "print(f\"\\nResults saved to '{output_file}'\")\n", "\n", "# ------------------------------------------------------------\n", "# 10. Best standard method comparison\n", "# ------------------------------------------------------------\n", "std_methods_only = [m for m in all_methods if m not in nnfa_methods]\n", "best_std = max(std_methods_only, key=lambda m: np.mean(metrics[m]['f1']))\n", "print(\"\\n\" + \"=\"*80)\n", "print(\"STATISTICAL SIGNIFICANCE (Wilcoxon test, two-sided, for F1)\")\n", "print(\"=\"*80)\n", "for nnfa_m in nnfa_methods:\n", " p_val = p_matrix.loc[nnfa_m, best_std]\n", " print(f\"{nnfa_m} vs {best_std}: p = {p_val:.6f} -> {'significant (p<0.05)' if p_val < 0.05 else 'NOT significant'}\")\n", "p_0_vs_1 = p_matrix.loc['NNFA (ξ=0)', 'NNFA (ξ=1)']\n", "print(f\"\\nNNFA (ξ=0) vs NNFA (ξ=1): p = {p_0_vs_1:.6f} -> {'significant' if p_0_vs_1 < 0.05 else 'NOT significant'}\")\n", "\n", "# ------------------------------------------------------------\n", "# 11. Download\n", "# ------------------------------------------------------------\n", "try:\n", " from google.colab import files\n", " files.download(output_file)\n", " files.download(\"pairwise_wilcoxon_matrix.csv\")\n", " print(\"Files downloaded automatically.\")\n", "except ImportError:\n", " print(f\"\\nFiles saved locally: '{output_file}', 'pairwise_wilcoxon_matrix.csv'\")\n", "\n", "# ------------------------------------------------------------\n", "# 12. Boxplot\n", "# ------------------------------------------------------------\n", "plt.figure(figsize=(14, 7))\n", "f1_data = [metrics[m]['f1'] for m in all_methods]\n", "plt.boxplot(f1_data, labels=all_methods)\n", "plt.xticks(rotation=90)\n", "plt.ylabel('F1 Score')\n", "plt.title(f'Distribution of F1 over {n_runs} runs (Concrete Strength, 20 outliers)')\n", "plt.grid(axis='y', linestyle=':', alpha=0.7)\n", "plt.tight_layout()\n", "plt.show()" ] } ] }