diff --git a/Python/rerf/pycy_usporf.py b/Python/rerf/pycy_usporf.py new file mode 100644 index 00000000..e107f94b --- /dev/null +++ b/Python/rerf/pycy_usporf.py @@ -0,0 +1,303 @@ +import numpy as np +import random as rn +import cy_usporf # Utilities functions + +class UForest(object): + """ UForest: USPORF forest + Creates an iForest object. This object holds the data as well as + the trained trees (iTree objects). + + Note: download `cy_usporf.pyx` and `setup.py` into your local + computer and compile them to generate and generate `.C` and `.so` + before using this module + + Parameters + ---------- + n_samples: int + Size of the dataset. + max_sample: int + Size of the sample to be used for tree creation. + Trees: list + A list of tree objects. + max_depth: int + Maximum depth a tree can have. + d: int + number of features in limit sparse matrix `A` + + References + ---------- + .. [#Meghana] Meghana et al (2019). + https://arxiv.org/abs/1907.02844 + + .. [#Fei] Fei Tony et al. (2009). + https://arxiv.org/abs/1506.03410 + + Methods + ------- + compute_paths(X_in) + Computes the anomaly score for data X_in + """ + def __init__(self, n_estimators, max_samples=None, + max_depth=None, d=None, Lambda=1/20): + self.n_estimators = n_estimators + self.max_samples = max_samples + self.max_depth = max_depth + self.d = d + self.Lambda = Lambda + # 1/20: prob of +1, -1 element in sparse projected matrix `A` + + def fit(self, X, y=None): + self.Trees = [] + self.X_ = X + n_samples = X.shape[0] + dim = X.shape[1] + + if self.max_samples is None: + self.max_samples = min(256, n_samples) + if self.max_depth is None: + self.max_depth = int(np.ceil(np.log2(self.max_samples))) + if self.d is None: + self.d = int(np.sqrt(dim)) + self.c = cy_usporf.c_factor(self.max_samples) + for i in range(self.n_estimators): # Ensemble of iTrees (the forest). + ix = rn.sample(range(n_samples), self.max_samples) # subset + X_p = X[ix] + self.Trees.append(iTree(X_p, 0, self.max_depth, d=self.d, + Lambda=self.Lambda)) + return self + + def compute_paths(self, X_in=None): + """ Compute paths(X_in = None) + + Compute anomaly scores for all data points in a dataset X_in + Parameters + ---------- + X_in : list of list of floats + Data to be scored. iForest.Trees are used for computing + the depth reached in each tree by each data point. + + Returns + ------- + float + Anomaly score for a given data point. The higher score, + the more anomaly. + """ + if X_in is None: + X_in = self.X_ + S = np.zeros(len(X_in)) + for i in np.arange(len(X_in)): + h_temp = 0 + for j in range(self.n_estimators): + h_temp += PathFactor(X_in[i], self.Trees[j]).path*1.0 + Eh = h_temp/self.n_estimators + # Average of path length travelled by the point in all trees. + S[i] = 2.0**(-Eh/self.c) # higher score, more anomaly + return S + + +class Node(object): + """Elements stored in tree node + A single node from each tree (each iTree object). Nodes containe + information on hyperplanes used for data division, date to be passed + to left and right nodes, whether they are external or internal nodes. + + Attributes + ---------- + e: int + Depth of the tree to which the node belongs. + size: int + Size of the dataset present at the node. + d: int + Dimension of the projected space + X: list + Data at the node. + Aj: list + project matrix column j + splitPoint: float + splitPoint/ split threshold + left: Node object + Left child node. + right: Node object + Right child node. + node_type: str + The type of the node: 'LeafNode', 'inNode'. + """ + def __init__(self, X, d, Aj, splitPoint, e, left, right, node_type=''): + self.e = e + self.size = len(X) + self.X = X + self.d = d + self.Aj = Aj + self.splitPoint = splitPoint + self.left = left + self.right = right + self.ntype = node_type + + +class iTree(object): # USPORF's algo 1 + """iTree: a single USPORF tree + A single tree in the forest that is build using a unique subsample. + + Attributes + ---------- + X: list + Data present at the root node of this tree. + e: int + Depth of a current node + max_depth: + length limit of the tree node + d: int + number of feature in a projected matrix `A` + Lambda: float + ratio of non-zero lement (-1 and 1) in a projected matrix `A` + + Methods + ------- + make_tree(X, e) + Builds the tree recursively from a given node. Returns a Node object. + """ + def __init__(self, X, e, max_depth, d, Lambda): + self.max_depth = max_depth + self.Lambda = Lambda + self.d = d + self.size = X.shape[0] # n: number of sample in the tree root + self.min_samples_split = int(np.sqrt(self.size)) # default + self.dim = X.shape[1] # p: number of original feature + self.d_list = np.arange(d, dtype='int') # [0,1,2,...,'d'-1] #? + self.Aj = None + self.splitPoint = None + self.LeafNodes = 0 # number of LeafNode / leaf node + self.root = self.make_tree(X, e) # Create a tree with root node. + + def make_tree(self, X, e): + """make_tree(X, e, l) + Builds the tree recursively from a given node. Returns a Node object. + + Parameters + ---------- + X: list of list of floats + Subsample of training data. |X| = iForest.max_samples. + Might not equal to the fist `X` in class iTree(): + e : int + Depth of the tree. e <= max_depth. + max_depth : int + The maximum depth the tree can reach before its creation + is terminated. Integer. + Returns + ------- + Node object + """ + if e >= self.max_depth or len(X) <= self.min_samples_split: + # LeafNode condition + left = None + right = None + self.LeafNodes += 1 + return Node(X, self.d, self.Aj, self.splitPoint, e, + left, right, node_type='LeafNode') + + else: # Build a tree recursively + A = cy_usporf.projectA(self.dim, self.d, self.Lambda) + XA = X @ A # [n*d] array + min_t = np.inf + for j in self.d_list: # dimension + (midpt, t_) = cy_usporf.FastBIC(XA[:, j]) + if t_ < min_t: + bestDim = j + splitPoint = midpt + + w = XA[:, bestDim] < splitPoint # spliting criteria + return Node(X, self.d, A[:, bestDim], splitPoint, e, + left=self.make_tree(X[w], e+1), + right=self.make_tree(X[~w], e+1), + node_type='inNode') + + +class PathFactor(object): + """ Path length finder + Given a single tree (iTree objext) and a data point x = [x1,x2,...,xn], + compute the legth of the path traversed by the point on the tree when + it reaches an external node. See Fei Tony et al. (2009) [#Fei]_ for + further details + + Attributes + ---------- + path_list: list + A list of strings 'L' or 'R' which traces the path + a data point travels down a tree. + x: list + A single data point, which is represented as a list of floats. + e: int + The depth of a given node in the tree. + itree: iTree object + A single tree + + Methods + ------- + find_path(T) + Given a tree, it finds the path a single data points takes. + """ + def __init__(self, x, itree): + self.path_list = [] + self.x = x + self.e = 0 + self.path = self.find_path(itree.root) + + def find_path(self, T): + """find_path(T) + Given a tree, find the path for a single data point based + on the splitting criteria stored at each node. + Parameters + ---------- + T : iTree object (iTree.root object) + + Returns + ------- + int + The depth reached by the data point. + """ + if T.ntype == 'LeafNode': + + if T.size <= 1: + return self.e + else: + self.e = self.e + cy_usporf.c_factor(T.size) + return self.e + else: + Aj = T.Aj + splitPoint = T.splitPoint + self.e += 1 + + if np.dot(self.x, Aj) < splitPoint: + self.path_list.append('L') + return self.find_path(T.left) + else: + self.path_list.append('R') + return self.find_path(T.right) + + +def all_branches(node, current=[], branches=None): + """ + Utility function used in generating a graph visualization. + It returns all the branches of a given tree so they can be visualized. + + Parameters + ---------- + node: Node object + + Returns + ------- + list + list of branches that were reached. + """ + current = current[:node.e] + if branches is None: + branches = [] + if node.ntype == 'inNode': + current.append('L') + all_branches(node.left, current=current, branches=branches) + current = current[:-1] + current.append('R') + all_branches(node.right, current=current, branches=branches) + else: + branches.append(current) + return branches diff --git a/Python/src/cy_usporf.pyx b/Python/src/cy_usporf.pyx new file mode 100644 index 00000000..07bc93ae --- /dev/null +++ b/Python/src/cy_usporf.pyx @@ -0,0 +1,236 @@ +import random as rn +import cython +import numpy as np + +from libc.stdlib cimport rand, RAND_MAX +from libc.math cimport log as ln # base e +from libc.math cimport M_PI +from sklearn.tree._utils cimport log # base 2 +cimport numpy as np + +np.import_array() + +DTYPE = np.int +ctypedef np.int_t DTYPE_t +FTYPE = np.float +ctypedef np.float_t FTYPE_t +cdef double INFINITY = np.inf +DEF CUTOFF = 17 +cdef double Euler_const = 0.5772156649 + + +def c_factor(int n): + """c_factor(int n) + Average path length of unsuccesful search in a binary + search tree given n points, using `ln` in C + + Parameters + ---------- + n : int + Number of data points for the binary search tree + (BST) + + Returns + ------- + float + Average path length of unsuccesful search in a BST + """ + return 2.0*(ln(n-1)+Euler_const) - (2.0*(n-1.)/(n*1.0)) + + +def projectA(int dim, int d, double Lambda=0.05): + """Sparse projected matrix + Create a sparse matrix `A` with shape(dim, d) + Lambda = non-zero element (-1 and 1) + Note: non-zero element must be at least one + + Parameters + ---------- + dim : int + Number of data raw features + d : int + Number of data projected features + + Returns + ------- + A : ndarray of shape (dim, d) + projected matrix + """ + cdef int i, i_new + cdef non_zeros = 0 + cdef int A_size = dim * d + cdef double p # random probability + cdef double Lambda_2 = Lambda*0.5 + cdef A = np.zeros((A_size,), dtype=float) + + for i in range(A_size): + p = uniform() + if p < Lambda_2: + A[i] = 1 + non_zeros += 1 + elif (p >= Lambda_2) and (p < Lambda): + A[i] = -1 + non_zeros += 1 + if non_zeros == 0: # there is no non-zero + i_new = int(rand()/RAND_MAX*A_size) + if (rand()/RAND_MAX) < 0.5: + A[i_new] = 1 + else: + A[i_new] = -1 + return A.reshape(dim, d) + + +cdef double uniform(): + """ + random number uniformly from [0,1] + """ + cdef double x1 = rand() + return x1/RAND_MAX + + +@cython.boundscheck(False) # Deactivate bounds checking +@cython.wraparound(False) # Deactivate negative indexing. +def FastBIC(np.ndarray[FTYPE_t, ndim=1] X_1d): + """Fast Bayesian Information Criterion score + Calculate the splitPoint and + min Bayesian information criterion (BIC) score + from 1D float array + + Parameters + ---------- + X_1d : ndarray of shape (N,) + projected matrix + + Returns + ------- + split_Point : float + splitting position + minBIC : float + minimum BIC score + """ + cdef int N = X_1d.shape[0] + cdef np.ndarray[FTYPE_t, ndim=1] X_sorted = sort(X_1d) + cdef np.ndarray[FTYPE_t, ndim=1] X_sorted_1 + cdef np.ndarray[FTYPE_t, ndim=1] X_sorted_2 + cdef FTYPE_t split_Point = X_sorted[0] + cdef double minBIC = INFINITY + cdef double BIC_diff_var, BIC_same_var, var_comb + + cdef Py_ssize_t s + cdef int n_1, n_2 + cdef double pi_0 = 1.0 + cdef double pi_1, pi_2 + + # var = sum(X-mu)^2/N = X_sumsq/N - (X_sum/N)^2 + cdef double X_sum = np.sum(X_sorted) + cdef double X_sumsq = np.sum(X_sorted**2) + cdef double X_sum_1 = 0 + cdef double X_sumsq_1 = 0 + cdef double X_sum_2 = X_sum + cdef double X_sumsq_2 = X_sumsq + cdef double i_1 = 1 + cdef double i_2 = N-1 + cdef double var_1 = 0.0 + cdef double var_2 = 0.0 + + pi_0 = pi_0/N + for s in range(0, N-1): + n_1 = s + n_2 = N-s + + X_sum_1 += X_sorted[s] + X_sumsq_1 += X_sorted[s]**2 + X_sum_2 -= X_sorted[s] + X_sumsq_2 -= X_sorted[s]**2 + + var_1 = (X_sumsq_1)/(n_1+1) - (X_sum_1/(n_1+1))**2 + if (var_1 == 0): + continue + var_2 = (X_sumsq_2)/(n_2-1) - (X_sum_2/(n_2-1))**2 + if (var_2 == 0): + continue + + pi_1 = s*pi_0 + pi_2 = 1-pi_1 + var_comb = (pi_1*var_1 + pi_2*var_2) + BIC_diff_var = -2*(n_1 * ln(pi_1) + - n_1/2 * ln(2*M_PI*var_1) + + n_2 * ln(pi_2) + - n_2/2 * ln(2*M_PI*var_2)) + BIC_same_var = -2*(n_1 * ln(pi_1) + - n_1/2 * ln(2*M_PI*var_comb) + + n_2 * ln(pi_2) + - n_2/2 * ln(2*M_PI*var_comb)) + + if BIC_diff_var > BIC_same_var: + BIC_diff_var = BIC_same_var + + if BIC_diff_var < minBIC: + minBIC = BIC_diff_var + split_Point = (X_sorted[s-1] + X_sorted[s])/2 + return(split_Point, minBIC) + + +cdef np.ndarray[FTYPE_t, ndim=1] sort(np.ndarray[FTYPE_t, ndim=1] a): + """Fast Sorting Function + Parameters + ---------- + a : ndarray of shape (N,) + projected matrix + + Returns + ------- + ndarray of shape (N,) + projected matrix + """ + qsort( a.data, 0, a.shape[0]) + return a + +cdef void qsort(FTYPE_t * a, Py_ssize_t start, Py_ssize_t end): + if (end - start) < CUTOFF: + insertion_sort(a, start, end) + return + cdef Py_ssize_t boundary = partition(a, start, end) + qsort(a, start, boundary) + qsort(a, boundary+1, end) + +cdef Py_ssize_t partition(FTYPE_t * a, Py_ssize_t start, Py_ssize_t end): + assert end > start + cdef Py_ssize_t i = start, j = end-1 + cdef FTYPE_t pivot = a[j] + while True: + # assert all(x < pivot for x in a[start:i]) + # assert all(x >= pivot for x in a[j:end]) + + while a[i] < pivot: + i += 1 + while i < j and pivot <= a[j]: + j -= 1 + if i >= j: + break + assert a[j] < pivot <= a[i] + swap(a, i, j) + assert a[i] < pivot <= a[j] + assert i >= j and i < end + swap(a, i, end-1) + assert a[i] == pivot + # assert all(x < pivot for x in a[start:i]) + # assert all(x >= pivot for x in a[i:end]) + return i + +cdef inline void swap(FTYPE_t * a, Py_ssize_t i, Py_ssize_t j): + a[i], a[j] = a[j], a[i] + +cdef void insertion_sort(FTYPE_t * a, Py_ssize_t start, Py_ssize_t end): + cdef Py_ssize_t i, j + cdef FTYPE_t v + for i in range(start, end): + # invariant: [start:i) is sorted + v = a[i] + j = i-1 + while j >= start: + if a[j] <= v: + break + a[j+1] = a[j] + j -= 1 + a[j+1] = v diff --git a/Python/src/setup.py b/Python/src/setup.py new file mode 100644 index 00000000..9b2119c2 --- /dev/null +++ b/Python/src/setup.py @@ -0,0 +1,7 @@ +from setuptools import setup +from Cython.Build import cythonize + +setup(ext_modules = cythonize("cy_usporf.pyx")) + +# For local Mac and Linux +# in terminal$ python setup.py build_ext --inplace diff --git a/docs/demos/URerF/3d_usporf_outlier_detection.ipynb b/docs/demos/URerF/3d_usporf_outlier_detection.ipynb new file mode 100644 index 00000000..7ea917ed --- /dev/null +++ b/docs/demos/URerF/3d_usporf_outlier_detection.ipynb @@ -0,0 +1,413 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Outlier detection comparison\n", + "\n", + "__Note__: to run the experiment and use\n", + "`import pycy_usporf` module\n", + "\n", + "- Open `SPORF/Python/rerf` and download the following\n", + "files into your local computer\n", + " - `pycy_usporf.py`\n", + "\n", + "- Open `SPORF/Python/src` and download the following\n", + "files into your local computer\n", + " - `cy_usporf.pyx` \n", + " - `setup.py`\n", + "- Open terminal, `cd` to the files location and run\n", + " - ```terminal\n", + "$ python setup.py build_ext --inplace\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "==================================================\n", + "Benchmark performance of USPORF in 3D toy dataset\n", + "==================================================\n", + "\n", + "This example compares the performance of isolarion forest (IF)\n", + "and USPORF on outlier detection with different 3D datasets.\n", + "\n", + "Algorithms:\n", + "- Isolation Forest, `sklearn.ensemble.IsolationForest`\n", + "- USPORF using distance matrix, `UnsupervisedRandomForest`\n", + " - C++ backend, cannot extract trees structure\n", + "- Usporf using path length, `pycy_usporf.UForest`\n", + " - Cython backend, can extract trees structure\n", + "\n", + "Benchmarks\n", + "- Accuracy_score: top left of each data figure\n", + "- Computational time: bottom right of each data figure \n", + "- AUC score: far right colum in ROC figures\n", + "\n", + "\"\"\"\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from pylab import *\n", + "import time\n", + "from sklearn.datasets import make_moons, make_blobs\n", + "from sklearn.metrics import accuracy_score\n", + "from sklearn.metrics import roc_auc_score\n", + "from sklearn.metrics import roc_curve\n", + "\n", + "from sklearn.ensemble import IsolationForest\n", + "from rerf.urerf import UnsupervisedRandomForest\n", + "import pycy_usporf \n", + "\n", + "## Note: to run an example\n", + "# Download `pycy_usporf.py` and `cy_usporf.pyx` \n", + "# into your local drive and generate `.so` module using `setup.py`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Experimental setup\n", + "===================\n", + "informative dimension = 5,\n", + "noise dimension = 5,\n", + "sample size = 500,\n", + "outlier fraction = 0.15\n" + ] + } + ], + "source": [ + "# Data parameter\n", + "d_noise = 5 # number of Gaussian dimensional noise\n", + "n_samples = 500\n", + "outliers_fraction = 0.15\n", + "n_outliers = int(outliers_fraction * n_samples)\n", + "n_inliers = n_samples - n_outliers\n", + "line_sd = 0.06 # sd of the line in dataset 1 and 2\n", + "cluster_sd = 0.2 # sd of the cluster in dataset 4 and 5\n", + "noise_sd = 2 # sd of the cluster in dimensional noise\n", + "\n", + "print(\"Experimental setup\\n===================\")\n", + "print(\"informative dimension = 5,\\nnoise dimension = %d,\" %(d_noise))\n", + "print(\"sample size = %d,\\noutlier fraction = %.2f\" %(\n", + " n_samples, outliers_fraction))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Define datasets\n", + "## 1: Linear\n", + "def fun_linear(samples=1, sd=0.0):\n", + " t_lin = np.transpose(np.linspace(-1, 1, samples))\n", + " X_lin = np.c_[\n", + " 0.4 * t_lin + sd * np.random.randn(samples),\n", + " 0.6 * t_lin + sd * np.random.randn(samples),\n", + " t_lin + sd * np.random.randn(samples),\n", + " ]\n", + " return X_lin\n", + "\n", + "\n", + "X_lin = fun_linear(samples=n_inliers, sd=line_sd)\n", + "\n", + "## 2: Helix\n", + "def fun_helix(samples=1, sd=0.0):\n", + " t_hex = np.transpose(np.linspace(2 * np.pi, 9 * np.pi, samples))\n", + " xline = t_hex * np.cos(t_hex) # before rescale\n", + " xline = xline / (max(xline) - min(xline)) * 2 + sd * np.random.randn(samples)\n", + " yline = t_hex * np.sin(t_hex) # before rescale\n", + " yline = yline / (max(yline) - min(yline)) * 2 + sd * np.random.randn(samples)\n", + " zline = (t_hex - (max(t_hex) + min(t_hex)) / 2) / (\n", + " max(t_hex) - min(t_hex)\n", + " ) * 2 + sd * np.random.randn(samples)\n", + " X_hex = np.c_[xline, yline, zline]\n", + " return X_hex\n", + "\n", + "\n", + "X_hex = fun_helix(samples=n_inliers, sd=line_sd)\n", + "\n", + "## 3: Sphere, equally distribution\n", + "def fibonacci_sphere(samples=1, randomize=True):\n", + " rnd = 1.0\n", + " if randomize:\n", + " rnd = np.random.random() * samples\n", + " points = []\n", + " offset = 2.0 / samples\n", + " increment = np.pi * (3.0 - np.sqrt(5.0))\n", + " for i in range(samples):\n", + " y = ((i * offset) - 1) + (offset / 2)\n", + " r = np.sqrt(1 - pow(y, 2))\n", + " phi = ((i + rnd) % samples) * increment\n", + " x = np.cos(phi) * r\n", + " z = np.sin(phi) * r\n", + " points.append([x, y, z])\n", + " return points\n", + "\n", + "\n", + "X_sph = np.array(fibonacci_sphere(samples=n_inliers))\n", + "\n", + "## 4: Gaussian Mixture\n", + "def gaussian_blobs(samples=3, sd=0.0):\n", + " blobs_params = dict(random_state=0, n_samples=samples, n_features=3)\n", + " X_gau = make_blobs(\n", + " centers=[[-0.7, -0.7, -0.7], [0, 0, 0], [0.7, 0.7, 0.7]],\n", + " cluster_std=[sd, sd, sd],\n", + " **blobs_params\n", + " )[0]\n", + " return X_gau\n", + "\n", + "\n", + "X_gau = gaussian_blobs(samples=n_inliers, sd=cluster_sd)\n", + "\n", + "## 5: Misaligned Gaussian Mixture\n", + "def misaligned_blobs(samples=3, sd=0.0):\n", + " blobs_params = dict(random_state=0, n_samples=samples, n_features=3)\n", + " X_misaligned = make_blobs(\n", + " centers=[[-0.7, -0.7, -0.7], [0.7, 0.7, -0.7], [-0.7, 0.7, 0.7]],\n", + " cluster_std=[sd, sd, sd],\n", + " **blobs_params\n", + " )[0]\n", + " return X_misaligned\n", + "\n", + "\n", + "X_misaligned = misaligned_blobs(samples=n_inliers, sd=cluster_sd)\n", + "\n", + "## 6: Whole dataset\n", + "datasets3D = [X_lin, X_hex, X_sph, X_gau, X_misaligned]\n", + "\n", + "# define to data label: y_true\n", + "y_true = np.concatenate([np.ones(n_inliers), -np.ones(n_outliers)], axis=0)\n", + "# label 1 as inliers, -1 as outliers" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Define algorithms\n", + "anomaly_algorithms = [\n", + " (\"IF\", IsolationForest(contamination=outliers_fraction,\n", + " random_state=42)),\n", + " (\"Usporf_distance\", UnsupervisedRandomForest(n_estimators=100, random_state=0)),\n", + " (\"Usporf_depth_cy\", pycy_usporf.UForest(n_estimators=100)),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# related functions\n", + "\n", + "def mat_to_score(mat, power =2):\n", + " s = (mat**power).sum(axis=1)/mat.shape[0]\n", + " return s\n", + "\n", + "def decision_function(s_train, s_test, less_inlier = True): # array\n", + " if s_test is None:\n", + " s_test=s_train\n", + " if less_inlier == True: \n", + " s_train = s_train\n", + " s_test = s_test\n", + " if less_inlier == False: \n", + " s_train = -s_train\n", + " s_test = -s_test\n", + " offset_ = np.percentile(s_train, outliers_fraction*100)\n", + " decision_function = s_test - offset_\n", + " return decision_function\n", + " \n", + "def OutPredict(decision_function):\n", + " is_inlier = np.ones(decision_function.shape[0], dtype=int)\n", + " is_inlier[decision_function <= 0] = -1\n", + " return is_inlier" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot\n", + "plt.figure(figsize=((len(anomaly_algorithms)) * 2.5 + 1, len(datasets3D) * 2 + 1))\n", + "plt.subplots_adjust(\n", + " left=0.02, right=0.98, bottom=0.001, top=0.98, wspace=0.05, hspace=0.01\n", + ")\n", + "plot_num = 1\n", + "rng = np.random.RandomState(42)\n", + "for i_dataset3D, X in enumerate(datasets3D):\n", + " # add uniform distribution outliers\n", + " X = np.concatenate([X, rng.uniform(low=-1.5, high=1.5, size=(n_outliers, 3))], axis=0)\n", + " # add Gaussian dimensional noise, set the center at origin\n", + " X = np.concatenate([X, 14.*(np.random.RandomState(42).rand(n_samples, d_noise))], axis=1)\n", + "\n", + " # list of AUC and ROC\n", + " list_AUC = []\n", + " list_fpr = []\n", + " list_tpr = []\n", + " list_thresh = []\n", + "\n", + "\n", + " algo_index = 0\n", + " for name, algorithm in anomaly_algorithms:\n", + " t0 = time.time()\n", + " algorithm.fit(X) \n", + "\n", + " # predict outlier\n", + " if name == \"Usporf_distance\":\n", + " d_sim = algorithm.transform()\n", + " s = mat_to_score(mat=d_sim)\n", + " probas_ = decision_function(s_train=s, s_test=s, less_inlier= True)\n", + " y_pred = OutPredict(decision_function=probas_)\n", + " elif name == \"Usporf_depth\" or name == \"Usporf_depth_cy\":\n", + " s = algorithm.compute_paths(X)\n", + " probas_ = decision_function(s_train=s, s_test=s, less_inlier= False)\n", + " y_pred = OutPredict(decision_function=probas_)\n", + " else:\n", + " probas_ = algorithm.fit(X).decision_function(X)\n", + " y_pred = algorithm.predict(X)\n", + "\n", + " AUC = roc_auc_score(y_true, probas_)\n", + " fpr, tpr, thresholds = roc_curve(y_true, probas_)\n", + " thresh_index = np.where(abs(thresholds) == min(abs(thresholds)))[0][0]\n", + " # store ROC curve\n", + " list_AUC.append(AUC)\n", + " list_fpr.append(fpr)\n", + " list_tpr.append(tpr)\n", + " list_thresh.append(thresh_index)\n", + " \n", + " \n", + " # compute the accuracy\n", + " acc = accuracy_score(y_true, y_pred)\n", + " t1 = time.time()\n", + " \n", + " # add data plot\n", + " ax = plt.subplot(\n", + " len(datasets3D), len(anomaly_algorithms)+1, plot_num, projection=\"3d\"\n", + " )\n", + " ax.axis(\"on\")\n", + " if i_dataset3D == 0:\n", + " plt.title(\n", + " str(algo_index + 1) + \") \" + name, size=10, color=\"black\", weight=\"bold\"\n", + " ) # use function's name for a title\n", + " colors = np.array([\"#377eb8\", \"#ff7f00\"])\n", + " # color plot ('blue' = outlier, 'orange'=inlier)\n", + " ax.scatter3D(X[:, 0], X[:, 1], X[:, 2], s=5, color=colors[((y_pred + 1) // 2)])\n", + " ax.text2D(\n", + " 0.01,\n", + " 0.85,\n", + " (\"acc %.3f\" % acc).lstrip(\"0\"),\n", + " transform=plt.gca().transAxes,\n", + " size=15,\n", + " horizontalalignment=\"left\",\n", + " )\n", + " ax.text2D(\n", + " 0.99,\n", + " 0.01,\n", + " (\"%.2fs\" % (t1 - t0)).lstrip(\"0\"),\n", + " transform=plt.gca().transAxes,\n", + " size=15,\n", + " horizontalalignment=\"right\",\n", + " )\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", + " ax.zaxis.set_ticklabels([])\n", + " algo_index += 1\n", + " plot_num += 1\n", + " \n", + "#------------------------------------------------------ \n", + "# plot the ROC curves and show AUC scores\n", + "\n", + " plt.subplot(len(datasets3D), len(anomaly_algorithms) + 1, plot_num) # +1 for ROC column\n", + "\n", + " if i_dataset3D == 0:\n", + " plt.title(\"ROC\", size=15, color=\"black\", weight=\"bold\")\n", + " \n", + " # lebel the decision_function's thresholds\n", + " plt.scatter([], [], marker=\"x\", color=\"black\", label=\"thresholds\")\n", + " \n", + " for algo_index in range(len(anomaly_algorithms)):\n", + " \n", + " if i_dataset3D == 0:\n", + " plt.plot(list_fpr[algo_index], list_tpr[algo_index],\n", + " label=\"algo \" + str(algo_index + 1)+ \")\"\n", + " + (\" AUC %.2f\" % list_AUC[algo_index]).lstrip(\"0\"))\n", + " else:\n", + " plt.plot(list_fpr[algo_index], list_tpr[algo_index],\n", + " label= str(algo_index + 1)+ \")\"\n", + " + (\" %.2f\" % list_AUC[algo_index]).lstrip(\"0\"))\n", + "\n", + " plt.scatter(\n", + " list_fpr[algo_index][list_thresh[algo_index]],\n", + " list_tpr[algo_index][list_thresh[algo_index]],\n", + " s=40, marker=\"x\", color = 'black')\n", + "\n", + " plt.plot(np.array([0, 1]), np.array([0, 1]), linestyle=\"--\", color=\"black\")\n", + " plt.legend()\n", + " plt.tick_params(labelleft = False, labelbottom = False, direction = \"in\")\n", + " plot_num += 1 \n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}