From 57bcd95e5d606f81c69bd816640e55ff8ec18716 Mon Sep 17 00:00:00 2001 From: Leszek Date: Tue, 25 Aug 2020 18:37:51 +0200 Subject: [PATCH 1/7] iTree_array: cpu & memory optimised; single-thread only --- eif_new.py | 196 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 196 insertions(+) create mode 100644 eif_new.py diff --git a/eif_new.py b/eif_new.py new file mode 100644 index 0000000..47e321d --- /dev/null +++ b/eif_new.py @@ -0,0 +1,196 @@ +""" Extended Isolation forest functions + +This is the implementation of the Extended Isolation Forest anomaly detection algorithm. This extension, improves the consistency and reliability of the anomaly score produced by standard Isolation Forest represented by Liu et al. +Our method allows for the slicing of the data to be done using hyperplanes with random slopes which results in improved score maps. The consistency and reliability of the algorithm is much improved using this extension. + +""" + +__author__ = 'Matias Carrasco Kind & Sahand Hariri (rewritten by Leszek Pryszcz)' +import numpy as np +import os +from version import __version__ + +def c_factor(n) : + """ + Average path length of unsuccesful search in a binary search tree given n points + + Parameters + ---------- + n : int + Number of data points for the BST. + + Returns + ------- + float + Average path length of unsuccesful search in a BST + """ + return 2.0*(np.log(n-1)+0.5772156649) - (2.0*(n-1.)/(n*1.0)) + +class iForest(object): + """ + Create an iForest object holding trees (iTree_array objects) trained on provided data (X). + + Parameters + ---------- + X : 2D array (samples, features) + Data to be trained on. + ntrees : int, default=200 + Number of trees in the forest. + sample : int, default=min(256, X.shape[1]) + Size of the sample to be used for tree creation. + limit : int, default=int(np.ceil(np.log2(sample))) + Maximum depth a tree can have. + exlevel: int, default=0 + Extension level to be used in the creating splitting critera. + random_state: int, default=None + Controls the pseudo-randomness of the selection of the feature + and split values for each branching step and each tree in the forest. + Pass an int for reproducible results across multiple function calls. + + Attributes + ---------- + Trees : list + A list of fitted tree objects. + + Methods + ------- + score_samples(X) + Computes the anomaly scores for data X. + """ + def __init__(self, X, ntrees=200, sample=256, limit=None, exlevel=0, random_state=None): + self.exlevel = exlevel + if self.exlevel < 0 or self.exlevel >= X.shape[1]: + raise Exception("Extension level has to be an integer between 0 and %s."%(X.shape[1]-1,)) + + # define random seed + if random_state is not None: + np.random.seed(random_state) + + self.ntrees = ntrees + self.sample = min(sample, X.shape[0]) + self.compute_paths = self.score_samples + # Set limit to the default as specified by the paper (average depth of unsuccesful search through a binary tree). + self.limit = limit if limit else int(np.ceil(np.log2(self.sample))) + # This loop builds an ensemble of iTrees (the forest). + self.Trees = [iTree(X[np.random.choice(X.shape[0], self.sample, replace=False)], + self.limit, self.exlevel) for i in range(self.ntrees)] + + def score_samples(self, X): + """ + Compute anomaly scores for all data points in a dataset X. + + Parameters + ---------- + X: 2D array (samples, features) + Data to be scored on. + + Returns + ------- + S: 1D array (X.shape[0]) + Anomaly scores calculated for all samples from all trees. + """ + Eh = np.zeros(X.shape[0]) + for t in self.Trees: + t.get_paths(X) + Eh += t.scores + del t.scores + Eh *= 1.0 / self.ntrees + S = 2.0**(-Eh / c_factor(self.sample)) + return S + +class iTree(object): + + """ + A single tree in the forest that is build using a unique subsample + and stored in numpy array. + + Attributes + ---------- + nodes: 2D array of shape (nodes, (n, pdotn, (left_child, right_child), size)) + An array storing tree structure and all information for splits. + dim: int + number of features + limit: int + max tree depth + exlevel: int + Exention level to be used in the creating splitting critera. + + Methods + ------- + get_paths(X) + Get tree depth reach for every sample from X and save it into self.scores. + """ + + def __init__(self, X, limit, exlevel): + self.limit = limit + self.dim = X.shape[1] + self.exlevel = exlevel + # for each split there can be n^2 new nodes, + # so in total sum(2^0, 2^1, ... 2^n) where n=limit + maxtreei = sum(2**i for i in range(0, self.limit+1)) + # sample from normal distribution in order to save time later + self.normal = np.random.normal(0, 1, size=(maxtreei, self.dim)) + self.uniform = np.random.uniform(size=(maxtreei, self.dim)) + if self.dim-self.exlevel-1: # shit, this may have replacements :/ + self.choice = np.random.choice(self.dim*maxtreei, size=(maxtreei, self.dim-self.exlevel-1), replace=False)%self.dim + # store all nodes in single array - here probably f2 would be more than enough + self.nodes = np.zeros(maxtreei, dtype="(%s,)f2, f2, 2u2, u2"%self.dim) + # track array population + self.treei = -1 + self._populate_nodes(X) + # trim unused nodes + self.nodes = self.nodes[:self.treei+1] + # clean-up + del self.normal, self.uniform, self.treei + if self.dim-self.exlevel-1: del self.choice + + def get_paths(self, X, nodei=0, e=0, idx=None): + """Stores the paths as self.scores for data + based on the splitting criteria stored at each node. + """ + # initialize tree + if not nodei: + idx = np.arange(X.shape[0]) + self.scores = np.zeros(X.shape[0]) + # unload node info + n, pdotn, (left, right), size = self.nodes[nodei] + # for internal nodes + if left: + # split data accordingly to each node criteria + w = X.dot(n) < pdotn + # and process two partition in child nodes - can this be multi threaded? + self.get_paths(X[w], left, e+1, idx[np.argwhere(w).flatten()]) + self.get_paths(X[~w], right, e+1, idx[np.argwhere(~w).flatten()]) + # store information from terminal nodes + else: + self.scores[idx] = e + c_factor(size) if size>1 else e + + def _populate_nodes(self, X, e=0): + """Builds the tree recursively from a given node (e). + By default starts from root note (e=0) + """ + self.treei += 1 + # for terminal nodes store only the size of dataset at final split + if e >= self.limit or len(X)<2: + self.nodes[self.treei][-1] = len(X) + # for internal nodes store everything + else: + # A random normal vector picked form a uniform n-sphere. Note that in order to pick uniformly from n-sphere, we need to pick a random normal for each component of this vector. + n = self.normal[self.treei] + # Pick the indices for which the normal vector elements should be set to zero acccording to the extension level. + if self.dim-self.exlevel-1: + n[self.choice[self.treei]] = 0 + # Picking a random intercept point for the hyperplane splitting data. + p = self.uniform[self.treei]*(X.max(axis=0)-X.min(axis=0)) + X.min(axis=0) + pdotn = p.dot(n) # calculating pdotn here will make classification faster and take less space to store + # Criteria that determines if a data point should go to the left or right child node. + w = X.dot(n) < pdotn + # add left nodes + idx = self.treei + nodeL = self.treei+1 + self._populate_nodes(X[w], e+1) + # add right nodes + nodeR = self.treei+1 + self._populate_nodes(X[~w], e+1) + # finally store current node + self.nodes[idx] = n, pdotn, (nodeL, nodeR), len(X) From 28b2434b06f94425022e3dbb5ed2c96d3efcc89e Mon Sep 17 00:00:00 2001 From: Leszek Date: Thu, 27 Aug 2020 16:43:34 +0200 Subject: [PATCH 2/7] further cpu optimisation; forced to single-thread --- Notebooks/comparison_py_cxx.ipynb | 1359 +++++++++++++++++++++++++++-- eif_new.py | 76 +- 2 files changed, 1361 insertions(+), 74 deletions(-) diff --git a/Notebooks/comparison_py_cxx.ipynb b/Notebooks/comparison_py_cxx.ipynb index d48d875..b5a2984 100644 --- a/Notebooks/comparison_py_cxx.ipynb +++ b/Notebooks/comparison_py_cxx.ipynb @@ -2,12 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "#!pip install -U numba\n", + "from numba import jit\n", "from scipy.stats import multivariate_normal\n", "import random as rn\n", "import eif as iso\n", @@ -23,14 +25,27 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "import sys\n", + "sys.path.insert(0, \"../\")\n", + "import eif_new as iso_new" + ] + }, + { + "cell_type": "code", + "execution_count": 328, "metadata": {}, "outputs": [], "source": [ "# Create data\n", "mean = [0, 0, 0 ]\n", "cov = [[1, 0, 0.], [0, 0.1, 0.0], [0,0,1]] # diagonal covariance\n", - "Nobjs = 500\n", + "Nobjs = 5000\n", "np.random.seed(1)\n", "x, y, z = np.random.multivariate_normal(mean, cov, Nobjs).T\n", "# Add manual outlier\n", @@ -42,153 +57,1399 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "rng = np.random.RandomState(42)" + "# Generate train data\n", + "#X = 0.3 * np.random.randn(1000, 10)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 329, "metadata": {}, "outputs": [], "source": [ - "Ntrees = 2000\n", + "rng = 42\n", + "Ntrees = 500\n", "Nsamples = 256" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 333, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4.195 sec, Scikit Learn\n" + ] + } + ], "source": [ "# scikit learn solution\n", "ss = time.time()\n", - "F0 = IsolationForest(n_estimators=Ntrees, behaviour='new', max_samples=Nsamples,random_state=rng, contamination=0.)\n", - "F0.fit(X)\n", + "F0 = IsolationForest(n_estimators=Ntrees, max_samples=Nsamples, random_state=rng).fit(X)\n", "S0 = F0.score_samples(X)*-1\n", - "ee = time.time()" + "ee = time.time()\n", + "print('{:.3f} sec, Scikit Learn'.format(ee-ss))" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 331, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "4.244 sec, Scikit Learn\n" + "12.376 sec, EIF Cython Version\n" ] } ], "source": [ - "print('{:.3f} sec, Scikit Learn'.format(ee-ss))" + "ss = time.time()\n", + "F1 = iso.iForest(X, ntrees=Ntrees, sample_size=Nsamples, ExtensionLevel=0, seed=rng)\n", + "S1 = F1.compute_paths(X_in=X)\n", + "ee = time.time()\n", + "print('{:.3f} sec, EIF Cython Version'.format(ee-ss))" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 334, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "422.010 sec, EIF Old Python Version\n" + ] + } + ], "source": [ "ss = time.time()\n", - "F1 = iso.iForest(X, ntrees=Ntrees, sample_size=Nsamples, ExtensionLevel=0)\n", - "S1 = F1.compute_paths(X_in=X)\n", - "ee = time.time()" + "F2 = iso2.iForest(X, ntrees=Ntrees, sample_size=Nsamples, ExtensionLevel=0)\n", + "S2 = F2.compute_paths(X_in=X)\n", + "ee = time.time()\n", + "print('{:.3f} sec, EIF Old Python Version'.format(ee-ss))" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 332, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2.139 sec, EIF Cython Version\n" + "15.307 sec, EIF New Python Version\n" ] } ], "source": [ - "print('{:.3f} sec, EIF Cython Version'.format(ee-ss))" + "import eif_new as iso_new\n", + "ss = time.time()\n", + "F3 = iso_new.iForest(X, ntrees=Ntrees, sample=Nsamples, exlevel=0, random_state=rng)\n", + "S3 = F3.compute_paths(X)\n", + "ee = time.time()\n", + "print('{:.3f} sec, EIF New Python Version'.format(ee-ss)) # 6.309 sec, EIF New Python Version\n", + "# 3.402 sec, EIF New Python Version score_samples0\n", + "# 5.821 sec, EIF New Python Version score_samples\n", + "# 2.097 sec, EIF New Python Version score_samples1 5000x3" + ] + }, + { + "cell_type": "code", + "execution_count": 335, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'Scores')" + ] + }, + "execution_count": 335, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,10))\n", + "sb.kdeplot(S0, lw=3, label='scikit', clip=(0.35, 0.8))\n", + "sb.kdeplot(S1, lw=3, label='eif_cxx', clip=(0.35, 0.8))\n", + "sb.kdeplot(S2, lw=3, label='eif_old', clip=(0.35, 0.8))\n", + "sb.kdeplot(S3, lw=3, label='eif_new', clip=(0.35, 0.8))\n", + "plt.legend(loc=0)\n", + "plt.xlabel('Scores')" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0:00:00.082970 5.49 Mb\n" + ] + } + ], + "source": [ + "import joblib, os\n", + "from datetime import datetime\n", + "ext = \"jbl\"\n", + "\n", + "t0 = datetime.now()\n", + "jbl_fn = \"eif_new.%s\"%ext\n", + "joblib.dump(F3, jbl_fn)\n", + "dt = datetime.now()-t0\n", + "print(\"%s %.2f Mb\"%(dt, os.stat(jbl_fn).st_size/1024**2)) # 0:00:00.877536 0.56 Mb\n", + "# 0:00:00.407903 0.28 Mb f2 0.44 Mb f4\n", + "# 0:00:00.079145 5.49 Mb f4 u2\n", + "# 0:00:00.079248 6.95 Mb f4 i4" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0:00:08.227051 42.72 Mb\n" + ] + } + ], + "source": [ + "t0 = datetime.now()\n", + "jbl_fn = \"eif_old.%s\"%ext\n", + "joblib.dump(F2, jbl_fn)\n", + "dt = datetime.now()-t0\n", + "print(\"%s %.2f Mb\"%(dt, os.stat(jbl_fn).st_size/1024**2)) #0:00:32.724675 6.83 Mb\n", + "# 0:00:17.224409 3.54 Mb\n", + "# 0:00:08.227051 42.72 Mb no compression" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 308, "metadata": {}, "outputs": [], "source": [ - "ss = time.time()\n", - "F2 = iso2.iForest(X, ntrees=Ntrees, sample_size=Nsamples, ExtensionLevel=0)\n", - "S2 = F2.compute_paths(X_in=X)\n", - "ee = time.time()" + "import eif_new as iso_new\n", + "F3 = iso_new.iForest(X, ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0)\n", + "#S3 = F3.compute_paths(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 357, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "751 ms ± 1.23 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "1.99 s ± 126 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "%timeit iso_new.iForest(X, ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0) #X.shape[1]-1)\n", + "%timeit F3.compute_paths(X)\n", + "# 749 ms ± 3.63 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) exlevel=0\n", + "# 361 ms ± 4.18 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) without p *min-max\n", + "\n", + "# 2.46 s ± 1.84 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "# 1.75 s ± 5.51 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) nonzero instead of argwhere\n", + "# 1.65 s ± 17 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) without nonzero\n", + "# 1.36 s ± 4.45 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) X.dot for all nodes\n", + "# 1.99 s ± 126 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) get_paths0\n", + "\n", + "# 752 ms ± 10.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) exlevel=2\n", + "# 2.48 s ± 22.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) " ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 338, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "47.351 sec, EIF Python Version\n" + "1 31 31.0 500\n", + "2 58 147.0 469\n", + "3 88 411.0 411\n", + "4 100 811.0 323\n", + "5 73 1176.0 223\n", + "6 58 1524.0 150\n", + "7 42 1818.0 92\n", + "8 0 2251.2732305771265 50 [ 1 4 2 6 1 5 1 2 1 2 5 2 1 4 20 2 1 1 0 1 1 10 3 1\n", + " 1 3 1 1 3 1 1 2 1 2 1 2 1 2 2 5 1 1 1 2 26 1 1 1\n", + " 1 1]\n" ] } ], "source": [ - "print('{:.3f} sec, EIF Python Version'.format(ee-ss))" + "def c_factor(n):\n", + " return np.sum(2.0*(np.log(n-1)+0.5772156649) - (2.0*(n-1.)/(n*1.0)))\n", + "\n", + "self = F3\n", + "S = np.zeros(X.shape[0])\n", + "trees = np.array([t.nodes for t in self.Trees])\n", + "n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\n", + "for xi in range(1): #X.shape[0]):\n", + " ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", + " tidx = np.arange(trees.shape[0])\n", + " for e in range(1, self.limit):\n", + " w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", + " ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T)\n", + " S[xi] += e*(ni==0).sum()\n", + " print(e, (ni==0).sum(), S[xi], len(ni))\n", + " tidx, ni = tidx[ni>0], ni[ni>0]\n", + " # the size matters only at terminal nodes\n", + " size = sizes[tidx, ni]\n", + " S[xi] += self.limit*len(ni) + c_factor(size[size>1])#.sum()\n", + " print(self.limit, (ni==0).sum(), S[xi], len(ni), size)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 311, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Text(0.5, 0, 'Scores')" + "array([364, 30, 157, 31, 409, 329, 472, 46, 142, 189, 145, 330, 485,\n", + " 479, 446, 143, 40, 447, 176, 453, 214, 16, 244, 457, 348, 184,\n", + " 61, 39, 336, 177, 237, 428, 94, 409, 30, 19, 167, 367, 475],\n", + " dtype=uint16)" ] }, - "execution_count": 12, + "execution_count": 311, "metadata": {}, "output_type": "execute_result" - }, + } + ], + "source": [ + "ni" + ] + }, + { + "cell_type": "code", + "execution_count": 306, + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "array([0.97761337, 0.66105967, 0.51744501, ..., 0.6299805 , 0.55715247,\n", + " 0.43243751])" ] }, + "execution_count": 306, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "plt.figure(figsize=(10,10))\n", - "sb.kdeplot(S0, lw=3, label='scikit', clip=(0.35, 0.8))\n", - "sb.kdeplot(S1, lw=3, label='eif_cxx', clip=(0.35, 0.8))\n", - "sb.kdeplot(S2, lw=3, label='eif_python', clip=(0.35, 0.8))\n", - "plt.legend(loc=0)\n", - "plt.xlabel('Scores')" + "S = F3.score_samples(X); S" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 307, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.74400223, 0.56587012, 0.4988135 , ..., 0.54653904, 0.5134962 ,\n", + " 0.44586648])" + ] + }, + "execution_count": 307, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "S1 = F3.score_samples1(X); S1" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "( C_CONTIGUOUS : True\n", + " F_CONTIGUOUS : False\n", + " OWNDATA : True\n", + " WRITEABLE : True\n", + " ALIGNED : True\n", + " WRITEBACKIFCOPY : False\n", + " UPDATEIFCOPY : False,\n", + " dtype([('n', '0], ni[ni>0]\n", + " # the size matters only at terminal nodes\n", + " size = sizes[tidx, ni]\n", + " S += e*len(ni) + c_factor(size[size>1])\n", + " return S\n", + "\n", + "def score_samples_by_sample1(X, trees, limit=8):\n", + " S = np.zeros(X.shape[0])\n", + " for xi in range(X.shape[0]):\n", + " S[xi] = score_sample1(X[xi], trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"], limit)\n", + " return S * 1. / len(trees)\n", + "\n", + "def score_sample(x, trees, limit, ni=0, S=0):\n", + " tidx = np.arange(trees.shape[0])\n", + " for e in range(limit):\n", + " w = x.dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni]\n", + " ni = np.where(w, trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", + " if e: S += e*(ni==0).sum()\n", + " tidx, ni = tidx[ni>0], ni[ni>0]\n", + " # the size matters only at terminal nodes\n", + " size = trees[\"size\"][tidx, ni]\n", + " S += e*len(ni) + c_factor(size[size>1])\n", + " return S\n", + "\n", + "def score_samples_by_sample(X, trees, limit=8):\n", + " S = np.zeros(X.shape[0])\n", + " for xi in range(X.shape[0]):\n", + " S[xi] = score_sample(X[xi], trees, limit)\n", + " return S * 1. / len(trees)\n", + "\n", + "def score_samples_by_sample_all(X, trees, limit=8):\n", + " S = np.zeros(X.shape[0])\n", + " for xi in range(X.shape[0]):\n", + " ni = 0\n", + " tidx = np.arange(trees.shape[0])\n", + " for e in range(limit):\n", + " w = X[xi].dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni]\n", + " ni = np.where(w, trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", + " if e: S[xi] += e*(ni==0).sum()\n", + " tidx, ni = tidx[ni>0], ni[ni>0]\n", + " # the size matters only at terminal nodes\n", + " size = trees[\"size\"][tidx, ni]\n", + " S[xi] += e*len(ni) + c_factor(size[size>1])\n", + " return S * 1. / len(trees)\n", + "\n", + "#%timeit score_samples_by_sample1(X, trees, F3.limit) #1.55 s ± 8.16 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "\n", + "\n", + "S = score_samples_by_sample(X, trees, F3.limit) \n", + "%timeit score_samples_by_sample(X, trees, F3.limit) #1.64 s ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "# 1.87 s ± 1.82 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) fully functional\n", + "# 1.79 s ± 3.35 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "%timeit score_samples_by_sample_all(X, trees, F3.limit) #1.64 s ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "# 2 s ± 4.48 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "\n", + "# 1.43 s ± 3.49 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) for f4 i4?\n", + "# 1.57 s ± 933 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) for f4 u2" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2, 4, 8, 16, 32, 64, 128, 256])" + ] + }, + "execution_count": 261, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "limit = 8\n", + "e=0; 2**(limit-e)\n", + "np.power(2, np.arange(1, limit+1))" + ] + }, + { + "cell_type": "code", + "execution_count": 269, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.42 s ± 4.08 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 3.512636 , 8.05164026, 10.16188574, ..., 8.66337866,\n", + " 9.64911035, 11.90239893])" + ] + }, + "execution_count": 269, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def score_samples_by_sample_all2(X, trees, limit=8):\n", + " S = np.zeros(X.shape[0])\n", + " n, pdotn, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"size\"]\n", + " #powers = np.power(2, np.arange(limit+1))\n", + " for xi in range(X.shape[0]):\n", + " e = 0\n", + " ni = np.zeros(len(trees), dtype='int')\n", + " w = X[xi].dot(n[:, 0].T) < pdotn[:, 0]\n", + " ni[w] += 1\n", + " ni[~w] += 2**(limit-e)\n", + " tidx = np.arange(trees.shape[0])\n", + " for e in range(1, limit):\n", + " w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", + " ni[w] += 1\n", + " ni[~w] += 2**(limit-e)\n", + " sel = sizes[tidx, ni]>1\n", + " S[xi] += e*(~sel).sum()\n", + " tidx, ni = tidx[sel], ni[sel]\n", + " # the size matters only at terminal nodes\n", + " size = sizes[tidx, ni]\n", + " S[xi] += e*len(ni) + c_factor(size[size>1])\n", + " return S * 1. / len(trees)\n", + "\n", + "%timeit score_samples_by_sample_all1(X, trees, F3.limit)\n", + "S2 = score_samples_by_sample_all2(X, trees, F3.limit); S2\n", + "#3.512636 , 8.05164026, 10.16188574, ..., 8.66337866," + ] + }, + { + "cell_type": "code", + "execution_count": 268, + "metadata": {}, + "outputs": [], + "source": [ + "%lprun -f score_samples_by_sample_all2 score_samples_by_sample_all2(X, trees)" + ] + }, + { + "cell_type": "code", + "execution_count": 275, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.42 s ± 2.68 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 4.370636 , 8.41564026, 10.27988574, ..., 8.92937866,\n", + " 9.85111035, 11.93839893])" + ] + }, + "execution_count": 275, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def score_samples_by_sample_all1(X, trees, limit=8):\n", + " S = np.zeros(X.shape[0])\n", + " n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\n", + " for xi in range(X.shape[0]):\n", + " ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", + " tidx = np.arange(trees.shape[0])\n", + " for e in range(1, limit):\n", + " w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", + " ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T)\n", + " S[xi] += e*(ni==0).sum()\n", + " tidx, ni = tidx[ni>0], ni[ni>0]\n", + " # the size matters only at terminal nodes\n", + " size = sizes[tidx, ni]\n", + " S[xi] += e*len(ni) + c_factor(size[size>1])\n", + " return S * 1. / len(trees)\n", + "\n", + "%timeit score_samples_by_sample_all1(X, trees, F3.limit)\n", + "# 1.4 s ± 3.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "\n", + "S1 = score_samples_by_sample_all1(X, trees, F3.limit); S1" + ] + }, + { + "cell_type": "code", + "execution_count": 276, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The line_profiler extension is already loaded. To reload it, use:\n", + " %reload_ext line_profiler\n" + ] + } + ], + "source": [ + "#!pip install line_profiler\n", + "%load_ext line_profiler\n", + "%lprun -f score_samples_by_sample_all1 score_samples_by_sample_all1(X, trees)" + ] + }, + { + "cell_type": "code", + "execution_count": 277, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([False, True, False, False, True, True, False, True, False,\n", + " True, False, True, False, False, True, True, False, False,\n", + " True, False, False, False, False, True, True, True, False,\n", + " True, False, True, False, False, True, True, True, True,\n", + " True, True, True, True, True, False, True, False, False,\n", + " True, False, True, True, True, False, False, False, False,\n", + " False, False, False, False, True, True, True, False, False,\n", + " False, False, False, True, True, False, True, False, False,\n", + " False, True, False, True, True, True, False, False, False,\n", + " False, False, False, False, True, False, True, True, False,\n", + " True, True, False, False, False, False, False, True, False,\n", + " True, False, True, False, False, True, False, False, False,\n", + " False, False, False, True, True, False, False, True, True,\n", + " False, False, False, False, True, True, False, False, False,\n", + " True, True, False, True, True, False, False, False, False,\n", + " False, True, False, False, True, False, False, False, True,\n", + " False, True, False, False, True, True, True, True, False,\n", + " False, False, False, False, False, False, True, False, False,\n", + " True, True, False, False, True, False, False, False, False,\n", + " False, True, False, False, True, True, False, False, True,\n", + " False, True, True, True, True, True, False, False, True,\n", + " True, True, False, False, False, True, True, False, True,\n", + " False, False, True, False, True, True, True, False, True,\n", + " True, True, False, True, False, True, False, False, False,\n", + " False, False, True, True, True, True, True, False, False,\n", + " True, False, False, False, True, False, True, False, True,\n", + " False, False, False, False, False, False, True, False, True,\n", + " True, True, False, False, False, False, True, True, True,\n", + " True, False, True, False, True, True, True, False, True,\n", + " True, True, False, False, True, True, False, True, True,\n", + " False, True, False, False, False, False, False, True, False,\n", + " True, False, True, True, False, False, True, True, False,\n", + " True, False, False, True, False, True, False, True, True,\n", + " True, True, True, False, False, True, True, False, False,\n", + " False, False, True, False, False, True, False, False, True,\n", + " False, True, False, True, True, True, False, True, False,\n", + " False, True, True, True, True, True, False, False, True,\n", + " True, True, True, False, True, True, True, False, False,\n", + " True, False, False, False, False, False, True, False, False,\n", + " False, False, False, False, False, False, False, True, True,\n", + " True, False, True, True, False, False, False, False, False,\n", + " True, True, False, False, True, True, True, True, False,\n", + " True, True, True, True, False, False, False, True, True,\n", + " True, False, False, True, True, False, False, True, True,\n", + " True, True, False, False, False, False, True, True, False,\n", + " False, False, False, True, True, True, True, True, True,\n", + " False, False, True, False, True, True, False, False, False,\n", + " True, False, False, False, True, True, False, True, False,\n", + " False, False, True, True, False, False, True, True, True,\n", + " True, False, False, True, True, False, True, True, False,\n", + " False, False, False, False, False, True, False, True, False,\n", + " False, True, False, True, True, True, False, False, False,\n", + " True, True, False, True, False, False, False, True, False,\n", + " True, False, True, True, False, True, False, True, False,\n", + " False, False, True, True, True, False, True, False, True,\n", + " True, False, False, False, True])" + ] + }, + "execution_count": 277, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w" + ] + }, + { + "cell_type": "code", + "execution_count": 278, + "metadata": {}, + "outputs": [], + "source": [ + "import eif_new as iso_new\n", + "F3 = iso_new.iForest(X, ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0)\n", + "trees = np.array([t.nodes for t in F3.Trees]); trees.flags, trees.dtype\n", + "\n", + "S = np.zeros(X.shape[0])\n", + "xi = ni = e = 0\n", + "tidx = np.arange(trees.shape[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 290, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((5000, 3), (500, 3), (5000, 500))" + ] + }, + "execution_count": 290, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w = X.dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni]\n", + "X.shape, trees[\"n\"][tidx, ni].T.shape, w.shape\n" + ] + }, + { + "cell_type": "code", + "execution_count": 292, + "metadata": {}, + "outputs": [ + { + "ename": "IndexError", + "evalue": "boolean index did not match indexed array along dimension 1; dimension is 3 but corresponding boolean dimension is 500", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#w[:10,:10]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m: boolean index did not match indexed array along dimension 1; dimension is 3 but corresponding boolean dimension is 500" + ] + } + ], + "source": [ + "#w[:10,:10]\n", + "#X[w]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ni = np.where(w, trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", + "if e: S[xi] += e*(ni==0).sum()\n", + "print(e, (ni<1).sum(), ni)\n", + "tidx, ni = tidx[ni>0], ni[ni>0]\n", + "e += 1" + ] + }, + { + "cell_type": "code", + "execution_count": 284, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10 µs ± 21.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n" + ] + }, + { + "data": { + "text/plain": [ + "((3,), (3, 500), (500,))" + ] + }, + "execution_count": 284, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[trees[[\"left\", \"right\"]][:, 0]]\n", + "%timeit X[xi].dot(trees[\"n\"][tidx, ni].T).shape\n", + "X[xi].shape, trees[\"n\"][tidx, ni].T.shape, X[xi].dot(trees[\"n\"][tidx, ni].T).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 283, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.78 ms ± 81.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" + ] + }, + { + "data": { + "text/plain": [ + "((5000, 3), (3, 500), (5000, 500))" + ] + }, + "execution_count": 283, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%timeit X.dot(trees[\"n\"][tidx, ni].T).shape\n", + "X.shape, trees[\"n\"][tidx, ni].T.shape, X.dot(trees[\"n\"][tidx, ni].T).shape" + ] + }, + { + "cell_type": "code", + "execution_count": 287, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([256, 1, 256, 1, 1, 1, 1, 256, 1, 1, 1, 1, 1,\n", + " 1, 256, 256, 256, 1, 1, 256, 1, 1, 256, 1, 1, 256,\n", + " 256, 256, 1, 256, 256, 256, 1, 1, 1, 1, 256, 1, 256,\n", + " 1, 1, 1, 256, 1, 1, 1, 256, 1, 1, 1, 256, 1,\n", + " 1, 1, 256, 1, 1, 256, 1, 1, 1, 256, 1, 256, 1,\n", + " 256, 1, 1, 256, 256, 1, 1, 1, 256, 256, 256, 1, 256,\n", + " 1, 1, 1, 1, 256, 256, 256, 256, 1, 1, 256, 1, 256,\n", + " 256, 1, 1, 1, 256, 1, 1, 256, 1, 1, 1, 256, 256,\n", + " 256, 1, 1, 1, 1, 1, 256, 1, 1, 1, 256, 1, 256,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 256, 256, 1, 1,\n", + " 1, 256, 1, 256, 256, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 256, 1, 1, 1, 256, 1, 256, 256, 1, 256, 1, 1,\n", + " 1, 256, 1, 1, 1, 1, 256, 256, 256, 256, 1, 256, 1,\n", + " 256, 1, 256, 1, 1, 1, 1, 256, 256, 1, 256, 1, 1,\n", + " 256, 256, 256, 1, 256, 256, 256, 1, 1, 256, 256, 256, 256,\n", + " 256, 1, 1, 1, 1, 256, 256, 256, 256, 1, 256, 1, 256,\n", + " 1, 1, 256, 1, 256, 1, 256, 1, 256, 1, 1, 256, 256,\n", + " 1, 1, 256, 256, 256, 1, 256, 256, 1, 1, 256, 256, 1,\n", + " 256, 1, 1, 256, 256, 1, 256, 256, 1, 256, 1, 1, 1,\n", + " 256, 256, 256, 1, 1, 256, 1, 1, 256, 256, 1, 256, 1,\n", + " 256, 1, 256, 1, 256, 1, 1, 1, 1, 1, 256, 1, 1,\n", + " 1, 1, 1, 256, 1, 1, 256, 1, 256, 1, 1, 256, 1,\n", + " 256, 256, 1, 256, 1, 1, 256, 1, 256, 256, 256, 256, 1,\n", + " 256, 256, 256, 1, 256, 1, 1, 256, 1, 256, 1, 256, 1,\n", + " 1, 256, 256, 1, 1, 256, 256, 256, 256, 256, 256, 256, 1,\n", + " 1, 256, 256, 1, 256, 256, 1, 256, 256, 1, 256, 256, 256,\n", + " 1, 256, 1, 256, 1, 256, 1, 1, 256, 1, 1, 256, 256,\n", + " 1, 1, 1, 256, 256, 256, 1, 1, 256, 1, 1, 256, 256,\n", + " 256, 1, 1, 256, 256, 256, 256, 256, 1, 1, 1, 1, 256,\n", + " 1, 256, 256, 256, 1, 1, 1, 1, 1, 256, 1, 256, 256,\n", + " 1, 256, 256, 256, 1, 1, 256, 256, 256, 1, 1, 256, 1,\n", + " 1, 1, 256, 256, 256, 256, 1, 256, 256, 1, 1, 256, 1,\n", + " 1, 1, 1, 256, 1, 256, 256, 1, 256, 1, 1, 1, 1,\n", + " 256, 256, 1, 1, 1, 1, 1, 1, 1, 256, 256, 256, 1,\n", + " 256, 256, 256, 256, 1, 1, 256, 256, 256, 1, 1, 1, 1,\n", + " 1, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,\n", + " 1, 1, 256, 256, 1, 1, 256, 256, 256, 1, 1, 256, 256,\n", + " 256, 1, 1, 256, 1, 1, 1, 256, 256, 256, 1, 256, 1,\n", + " 1, 1, 256, 1, 256, 1], dtype=uint16),\n", + " array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,\n", + " 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,\n", + " 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,\n", + " 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,\n", + " 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", + " 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,\n", + " 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,\n", + " 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,\n", + " 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,\n", + " 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,\n", + " 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,\n", + " 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,\n", + " 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,\n", + " 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,\n", + " 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,\n", + " 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,\n", + " 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,\n", + " 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,\n", + " 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,\n", + " 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,\n", + " 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,\n", + " 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,\n", + " 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,\n", + " 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311,\n", + " 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,\n", + " 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337,\n", + " 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350,\n", + " 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363,\n", + " 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376,\n", + " 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389,\n", + " 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402,\n", + " 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415,\n", + " 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428,\n", + " 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441,\n", + " 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454,\n", + " 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467,\n", + " 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,\n", + " 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493,\n", + " 494, 495, 496, 497, 498, 499]))" + ] + }, + "execution_count": 287, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#ni, tidx, " + ] + }, + { + "cell_type": "code", + "execution_count": 279, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0 [256 1 256 1 1 1 1 256 1 1 1 1 1 1 256 256 256 1\n", + " 1 256 1 1 256 1 1 256 256 256 1 256 256 256 1 1 1 1\n", + " 256 1 256 1 1 1 256 1 1 1 256 1 1 1 256 1 1 1\n", + " 256 1 1 256 1 1 1 256 1 256 1 256 1 1 256 256 1 1\n", + " 1 256 256 256 1 256 1 1 1 1 256 256 256 256 1 1 256 1\n", + " 256 256 1 1 1 256 1 1 256 1 1 1 256 256 256 1 1 1\n", + " 1 1 256 1 1 1 256 1 256 1 1 1 1 1 1 1 1 1\n", + " 256 256 1 1 1 256 1 256 256 1 1 1 1 1 1 1 1 1\n", + " 256 1 1 1 256 1 256 256 1 256 1 1 1 256 1 1 1 1\n", + " 256 256 256 256 1 256 1 256 1 256 1 1 1 1 256 256 1 256\n", + " 1 1 256 256 256 1 256 256 256 1 1 256 256 256 256 256 1 1\n", + " 1 1 256 256 256 256 1 256 1 256 1 1 256 1 256 1 256 1\n", + " 256 1 1 256 256 1 1 256 256 256 1 256 256 1 1 256 256 1\n", + " 256 1 1 256 256 1 256 256 1 256 1 1 1 256 256 256 1 1\n", + " 256 1 1 256 256 1 256 1 256 1 256 1 256 1 1 1 1 1\n", + " 256 1 1 1 1 1 256 1 1 256 1 256 1 1 256 1 256 256\n", + " 1 256 1 1 256 1 256 256 256 256 1 256 256 256 1 256 1 1\n", + " 256 1 256 1 256 1 1 256 256 1 1 256 256 256 256 256 256 256\n", + " 1 1 256 256 1 256 256 1 256 256 1 256 256 256 1 256 1 256\n", + " 1 256 1 1 256 1 1 256 256 1 1 1 256 256 256 1 1 256\n", + " 1 1 256 256 256 1 1 256 256 256 256 256 1 1 1 1 256 1\n", + " 256 256 256 1 1 1 1 1 256 1 256 256 1 256 256 256 1 1\n", + " 256 256 256 1 1 256 1 1 1 256 256 256 256 1 256 256 1 1\n", + " 256 1 1 1 1 256 1 256 256 1 256 1 1 1 1 256 256 1\n", + " 1 1 1 1 1 1 256 256 256 1 256 256 256 256 1 1 256 256\n", + " 256 1 1 1 1 1 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 1 1 256 256 1 1 256 256 256 1 1 256 256 256 1 1 256 1\n", + " 1 1 256 256 256 1 256 1 1 1 256 1 256 1]\n" + ] + } + ], + "source": [ + "#for e in range(limit):\n", + "pni = ni\n", + "w = X[xi].dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni]\n", + "ni = np.where(w, trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", + "if e: S[xi] += e*(ni==0).sum()\n", + "print(e, (ni<1).sum(), ni)\n", + "tidx, ni = tidx[ni>0], ni[ni>0]\n", + "e += 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# the size matters only at terminal nodes\n", + "size = trees[\"size\"][tidx, ni]\n", + "S[xi] += e*len(ni) + c_factor(size[size>1])" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.48 s ± 6.93 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "def score_samples_by_sample_all2(X, trees, limit=8):\n", + " S = np.zeros(X.shape[0])\n", + " n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\n", + " for xi in range(X.shape[0]):\n", + " ni = 0\n", + " tidx = np.arange(trees.shape[0])\n", + " w = X[xi].dot(n[:, ni].T) < pdotn[:, ni]\n", + " _w = np.empty_like(w)\n", + " l = r = 0\n", + " for e in range(1, limit):\n", + " l, r = left[0, l], right[0, r]\n", + " _w[w] = X[xi].dot(n[tidx[w], l].T) < pdotn[tidx[w], l]\n", + " _w[~w] = X[xi].dot(n[tidx[~w], r].T) < pdotn[tidx[~w], r]\n", + " ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T)\n", + " S[xi] += e*(ni==0).sum()\n", + " tidx, ni = tidx[ni>0], ni[ni>0]\n", + " # the size matters only at terminal nodes\n", + " size = sizes[tidx, ni]\n", + " S[xi] += e*len(ni) + c_factor(size[size>1])\n", + " return S * 1. / len(trees)\n", + "\n", + "%timeit score_samples_by_sample_all1(X, trees, F3.limit)" + ] + }, + { + "cell_type": "code", + "execution_count": 219, + "metadata": {}, + "outputs": [], + "source": [ + "#n, pdotn, childs, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"childs\"], trees[\"size\"]\n", + "xi = ni = 0\n", + "e = 1\n", + "tidx = np.arange(trees.shape[0])\n", + "w = X[xi].dot(trees[\"n\"][:, ni].T) < trees[\"pdotn\"][:, ni]\n", + "_w = np.empty_like(w)\n", + "l = r = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 223, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((500,), (500,), 268)" + ] + }, + "execution_count": 223, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w.shape, tidx.shape, w.sum() #((500,), (500,), 268)\n", + "#trees[\"left\"][tidx[w], l]" + ] + }, + { + "cell_type": "code", + "execution_count": 225, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", + " 1 1 1 1 1 1 1 1 1] [256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", + " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256] 231\n" + ] + } + ], + "source": [ + "l, r = trees[\"left\"][tidx[w], l], trees[\"right\"][tidx[~w], r] #trees[\"childs\"][l] # trees[\"childs\"][0, l] \n", + "_w[w] = X[xi].dot(trees[\"n\"][tidx[w], l].T) < trees[\"pdotn\"][tidx[w], l]\n", + "_w[~w] = X[xi].dot(trees[\"n\"][tidx[~w], r].T) < trees[\"pdotn\"][tidx[~w], r]\n", + "w = _w\n", + "\n", + "#S[xi] += e*(ni==0).sum()\n", + "#tidx, ni = tidx[ni>0], ni[ni>0]\n", + "print(e, l, r, w.sum())\n", + "e += 1\n" + ] + }, + { + "cell_type": "code", + "execution_count": 226, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((500,), (500,), (268,), 231)" + ] + }, + "execution_count": 226, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "w.shape, tidx.shape, l.shape, w.sum() #((500,), (500,), 268)\n", + "#trees[\"left\"][tidx[w], l]" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1, 256], dtype=uint16)" + ] + }, + "execution_count": 189, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trees[\"childs\"][0, l]" + ] + }, + { + "cell_type": "code", + "execution_count": 236, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The line_profiler extension is already loaded. To reload it, use:\n", + " %reload_ext line_profiler\n" + ] + } + ], + "source": [ + "#!pip install line_profiler\n", + "%load_ext line_profiler\n", + "%lprun -f score_samples_by_sample_all1 score_samples_by_sample_all1(X, trees)" + ] + }, + { + "cell_type": "code", + "execution_count": 428, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2.02 s ± 771 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "2\n", + "1.07 s ± 49.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "3\n", + "740 ms ± 1.22 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "4\n", + "652 ms ± 626 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "5\n", + "562 ms ± 2.64 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "6\n", + "577 ms ± 19.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "7\n", + "587 ms ± 27.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "8\n", + "562 ms ± 49.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "9\n", + "543 ms ± 42.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "10\n", + "555 ms ± 43.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "11\n", + "553 ms ± 38.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "12\n", + "537 ms ± 2.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] + } + ], + "source": [ + "def worker(args):\n", + " Xi = args\n", + " ni = 0\n", + " S = 0\n", + " tidx = np.arange(trees.shape[0])\n", + " for e in range(F3.limit):\n", + " pni = ni\n", + " ni = np.where(Xi.dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni], trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", + " sel = ni>0\n", + " if e: S += e*(~sel).sum()\n", + " tidx, ni = tidx[sel], ni[sel]\n", + " # the size matters only at terminal nodes\n", + " size = trees[tidx, ni][\"size\"]\n", + " S += e*len(ni) + c_factor(size[size>1]).sum() \n", + " return S\n", + "\n", + "def score_samples_by_sample_pool(X, trees, nproc=6):\n", + " S = np.zeros(X.shape[0])\n", + " import multiprocessing as mp\n", + " with mp.Pool(nproc) as p:\n", + " iterable = (X[xi] for xi in range(X.shape[0]))\n", + " for i, si in enumerate(p.imap(worker, iterable, 100)):\n", + " S[i] = si\n", + " return S/len(trees)\n", + "\n", + "#%timeit score_samples_by_sample_pool(X, trees, 1) #1.96 s ± 50.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "#%timeit score_samples_by_sample_pool(X, trees, 6) # 484 ms ± 34.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "for i in range(1, 13):\n", + " print(i)\n", + " %timeit score_samples_by_sample_pool(X, trees, i) # 484 ms ± 34.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)" + ] + }, + { + "cell_type": "code", + "execution_count": 431, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " " + ] + } + ], + "source": [ + "%prun score_samples_by_sample(X, trees)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def score_samples_by_tree(X, trees):\n", + " S = np.zeros(X.shape[0])\n", + " for ti in range(len(trees)):\n", + " ni = 0\n", + " xidx = np.arange(X.shape[0])\n", + " for e in range(F3.limit+1):\n", + " pni = ni\n", + " ni = np.where(X.dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni], trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", + " tidx, ni = tidx[ni>0], ni[ni>0]\n", + " S[xi] += e*len(ni<1) # + c_factor(size) #trees[tidx[ni<1], pni[ni<1]][[\"size\", \"e\"]]\n", + " return S\n", + "\n", + "%timeit score_sample_by_sample(X, trees) #1.64 s ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)" + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[]\n" + ] + } + ], + "source": [ + "pni = ni\n", + "ni = np.where(X[xi].dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni], trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", + "print(trees[tidx[ni<1], pni[ni<1]][[\"size\", \"e\"]]) #ni.shape, ni[:10])#, trees[tidx[ni<1], ni[ni<1]][\"e\"])\n", + "tidx, ni = tidx[ni>0], ni[ni>0]\n" + ] }, { "cell_type": "code", @@ -214,7 +1475,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.7" + "version": "3.7.6" } }, "nbformat": 4, diff --git a/eif_new.py b/eif_new.py index 47e321d..ca5ad39 100644 --- a/eif_new.py +++ b/eif_new.py @@ -10,7 +10,7 @@ import os from version import __version__ -def c_factor(n) : +def c_factor(n): """ Average path length of unsuccesful search in a binary search tree given n points @@ -24,6 +24,7 @@ def c_factor(n) : float Average path length of unsuccesful search in a BST """ + #if n<2: return 0 return 2.0*(np.log(n-1)+0.5772156649) - (2.0*(n-1.)/(n*1.0)) class iForest(object): @@ -68,14 +69,15 @@ def __init__(self, X, ntrees=200, sample=256, limit=None, exlevel=0, random_stat self.ntrees = ntrees self.sample = min(sample, X.shape[0]) - self.compute_paths = self.score_samples + self.compute_paths = self.score_samples1 # Set limit to the default as specified by the paper (average depth of unsuccesful search through a binary tree). - self.limit = limit if limit else int(np.ceil(np.log2(self.sample))) - # This loop builds an ensemble of iTrees (the forest). - self.Trees = [iTree(X[np.random.choice(X.shape[0], self.sample, replace=False)], - self.limit, self.exlevel) for i in range(self.ntrees)] - - def score_samples(self, X): + self.limit = limit if limit else int(np.ceil(np.log2(self.sample))) + # This loop builds an ensemble of iTrees (the forest). + idx = np.random.choice(X.shape[0], (self.ntrees, self.sample)) + self.Trees = [iTree(X[idx[i]], self.limit, self.exlevel) for i in range(self.ntrees)] + #self.Trees = [iTree(X[np.random.choice(X.shape[0], self.sample, replace=False)], self.limit, self.exlevel) for i in range(self.ntrees)] + + def score_samples1(self, X): """ Compute anomaly scores for all data points in a dataset X. @@ -89,15 +91,34 @@ def score_samples(self, X): S: 1D array (X.shape[0]) Anomaly scores calculated for all samples from all trees. """ + S = np.zeros(X.shape[0]) + trees = np.array([t.nodes for t in self.Trees]) + n, pdotn, left, right, sizes = trees["n"], trees["pdotn"], trees["left"], trees["right"], trees["size"] + for xi in range(X.shape[0]): + ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T) + tidx = np.arange(trees.shape[0]) + for e in range(1, self.limit): + w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni] + ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T) + S[xi] += e*(ni==0).sum() + tidx, ni = tidx[ni>0], ni[ni>0] + # the size matters only at terminal nodes + size = sizes[tidx, ni] + S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum() + S *= 1. / len(trees) + S = 2.0**(-S / c_factor(self.sample)) + return S + + def score_samples0(self, X): Eh = np.zeros(X.shape[0]) for t in self.Trees: - t.get_paths(X) + t.get_paths(X=X) Eh += t.scores del t.scores Eh *= 1.0 / self.ntrees S = 2.0**(-Eh / c_factor(self.sample)) return S - + class iTree(object): """ @@ -126,44 +147,47 @@ def __init__(self, X, limit, exlevel): self.dim = X.shape[1] self.exlevel = exlevel # for each split there can be n^2 new nodes, - # so in total sum(2^0, 2^1, ... 2^n) where n=limit - maxtreei = sum(2**i for i in range(0, self.limit+1)) + # so in total sum(2^0, 2^1, ... 2^n) where n=limit+2 + maxtreei = 2**(self.limit+1)-1 # sample from normal distribution in order to save time later self.normal = np.random.normal(0, 1, size=(maxtreei, self.dim)) self.uniform = np.random.uniform(size=(maxtreei, self.dim)) if self.dim-self.exlevel-1: # shit, this may have replacements :/ - self.choice = np.random.choice(self.dim*maxtreei, size=(maxtreei, self.dim-self.exlevel-1), replace=False)%self.dim + self.choice = np.random.choice(self.dim, size=(maxtreei, self.dim-self.exlevel-1)) # store all nodes in single array - here probably f2 would be more than enough - self.nodes = np.zeros(maxtreei, dtype="(%s,)f2, f2, 2u2, u2"%self.dim) + dtype = [("n", "%sf4"%self.dim), ("pdotn", "f4"), ("left", "u2"), ("right", "u2"), ("size", "u2")] + self.nodes = np.zeros(maxtreei, dtype=dtype) # track array population self.treei = -1 self._populate_nodes(X) # trim unused nodes - self.nodes = self.nodes[:self.treei+1] + #self.nodes = self.nodes[:self.treei+1] # clean-up del self.normal, self.uniform, self.treei if self.dim-self.exlevel-1: del self.choice - def get_paths(self, X, nodei=0, e=0, idx=None): + def get_paths(self, X=[], nodei=0, e=0, idx=None): """Stores the paths as self.scores for data based on the splitting criteria stored at each node. """ - # initialize tree + # initialise if not nodei: idx = np.arange(X.shape[0]) self.scores = np.zeros(X.shape[0]) - # unload node info - n, pdotn, (left, right), size = self.nodes[nodei] + # unload data + n, pdotn, left, right, size = self.nodes[nodei] # for internal nodes if left: # split data accordingly to each node criteria w = X.dot(n) < pdotn # and process two partition in child nodes - can this be multi threaded? - self.get_paths(X[w], left, e+1, idx[np.argwhere(w).flatten()]) - self.get_paths(X[~w], right, e+1, idx[np.argwhere(~w).flatten()]) + self.get_paths(X[w], left, e+1, idx[w]) + self.get_paths(X[~w], right, e+1, idx[~w]) # store information from terminal nodes + elif size>1: + self.scores[idx] = e + c_factor(size) if size>1 else 0 else: - self.scores[idx] = e + c_factor(size) if size>1 else e + self.scores[idx] = e #+ c_factor(size) if size>1 else 0 def _populate_nodes(self, X, e=0): """Builds the tree recursively from a given node (e). @@ -171,8 +195,10 @@ def _populate_nodes(self, X, e=0): """ self.treei += 1 # for terminal nodes store only the size of dataset at final split - if e >= self.limit or len(X)<2: - self.nodes[self.treei][-1] = len(X) + if e==self.limit or len(X)<2: + self.nodes["size"][self.treei] = len(X) + # and make sure all trees have nodes in identical positions/order in the array + if e Date: Thu, 27 Aug 2020 17:57:48 +0200 Subject: [PATCH 3/7] further cpu optimisation; forced to single-thread --- Notebooks/comparison_py_cxx.ipynb | 708 +++--------------------------- eif_new.py | 259 ++++++----- 2 files changed, 195 insertions(+), 772 deletions(-) diff --git a/Notebooks/comparison_py_cxx.ipynb b/Notebooks/comparison_py_cxx.ipynb index b5a2984..1967c1c 100644 --- a/Notebooks/comparison_py_cxx.ipynb +++ b/Notebooks/comparison_py_cxx.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 328, + "execution_count": 343, "metadata": {}, "outputs": [], "source": [ @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 329, + "execution_count": 344, "metadata": {}, "outputs": [], "source": [ @@ -78,14 +78,14 @@ }, { "cell_type": "code", - "execution_count": 333, + "execution_count": 347, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "4.195 sec, Scikit Learn\n" + "0.947 sec, Scikit Learn\n" ] } ], @@ -100,14 +100,14 @@ }, { "cell_type": "code", - "execution_count": 331, + "execution_count": 348, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "12.376 sec, EIF Cython Version\n" + "1.355 sec, EIF Cython Version\n" ] } ], @@ -121,14 +121,14 @@ }, { "cell_type": "code", - "execution_count": 334, + "execution_count": 349, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "422.010 sec, EIF Old Python Version\n" + "44.257 sec, EIF Old Python Version\n" ] } ], @@ -137,26 +137,26 @@ "F2 = iso2.iForest(X, ntrees=Ntrees, sample_size=Nsamples, ExtensionLevel=0)\n", "S2 = F2.compute_paths(X_in=X)\n", "ee = time.time()\n", - "print('{:.3f} sec, EIF Old Python Version'.format(ee-ss))" + "print('{:.3f} sec, EIF Old Python Version'.format(ee-ss)) # 422 sec vs 15 new" ] }, { "cell_type": "code", - "execution_count": 332, + "execution_count": 345, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "15.307 sec, EIF New Python Version\n" + "2.184 sec, EIF New Python Version\n" ] } ], "source": [ "import eif_new as iso_new\n", "ss = time.time()\n", - "F3 = iso_new.iForest(X, ntrees=Ntrees, sample=Nsamples, exlevel=0, random_state=rng)\n", + "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, exlevel=0, random_state=rng).fit(X)\n", "S3 = F3.compute_paths(X)\n", "ee = time.time()\n", "print('{:.3f} sec, EIF New Python Version'.format(ee-ss)) # 6.309 sec, EIF New Python Version\n", @@ -167,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 335, + "execution_count": 346, "metadata": {}, "outputs": [ { @@ -176,13 +176,13 @@ "Text(0.5, 0, 'Scores')" ] }, - "execution_count": 335, + "execution_count": 346, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAJNCAYAAAD+qksAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeXhc9Xn//feZRZoZrZYtWZtt4Q2823jDGzuErZCmfcovgYTSpw2QtOmVpnnI9Txpwq/h1/Zq88tCA6Fp+5D0CW1oSErSBIhtMMEYYrzEeMEstixZsrxqHWm0zHKeP87MOWckGSxb0sxIn9d1cfnMme858x1JuXJf3/s+99cwTRMRERERuXCeTE9AREREJNcogBIREREZIQVQIiIiIiOkAEpERERkhBRAiYiIiIyQAigRERGREfKN54dNmzbNrKurG8+PFBEREbkoe/bsOWeaZvlw741rAFVXV8fu3bvH8yNFRERELophGI3ne08pPBEREZERUgAlIiIiMkIKoERERERGaFxroERERGR8RaNRmpub6evry/RUslYgEKC2tha/33/B1yiAEhERmcCam5spKiqirq4OwzAyPZ2sY5omra2tNDc3c9lll13wdUrhiYiITGB9fX1MnTpVwdN5GIbB1KlTR7xCpwBKRERkglPw9MEu5uejAEpEREQybvfu3Xzuc58D4JFHHuHrX//6kDFf+cpX2Lp1KwDf+ta3iEQi4zpHN9VAiYiISMatWrWKVatWfeCYv/7rv7aPv/Wtb3HvvfcSCoXGemrD0gqUiIiIjJmenh5uv/12li1bxuLFi3nmmWfYtWsX69evZ9myZaxZs4ZwOMwrr7zCHXfcMeT6f/7nf+bWW2+lt7eXP/zDP+TZZ5/lscceo6Wlheuuu47rrrsuA99KK1AiIiIyhl588UWqq6v55S9/CUBnZycrVqzgmWeeYfXq1XR1dREMBoe99jvf+Q5btmzhueeeIz8/3z7/uc99jm984xts27aNadOmjcv3GEwBlIiIyCRR96Vfjtm9G/7u9mHPL1myhC984Qs8/PDD3HHHHZSWllJVVcXq1asBKC4uHva6f/u3f2PGjBk899xzI+rPNF6UwhMREZExM3/+fPbu3cuSJUv48pe/zE9/+tMLum7JkiU0NDTQ3Nw8xjO8OAqgREREZMy0tLQQCoW49957+eIXv8jOnTs5efIku3btAiAcDhOLxYZct2LFCv7pn/6JO++8k5aWliHvFxUVEQ6Hx3z+56MUnoiIyCRxvjTbWDpw4ABf/OIX8Xg8+P1+vvvd72KaJn/2Z39Gb28vwWDQbk0w2MaNG/n617/O7bffzpYtW9Le+/SnP80tt9xCdXU127ZtG4+vksYwTXPcPmzVqlXm7t27x+3zREREJrvDhw+zYMGCTE8j6w33czIMY49pmsP2VlAKT0RERGSEFECJiIiIjJACKBEREZERUgAlIiIiMkIKoERERERGSAGUiIiIyAgpgJrAmtoi/PdbLXREBjI9FRERkQlFAdQEk0iYbH//LH/8g91c/Q/b+LP/+C23fXs7Z8P9mZ6aiIiI7bbbbqOjowOAxx57jAULFnDPPfdkeFYXTp3IJ5C9x9v5yx+/Rf3ZnrTzxV3v8ez3fs2nl3jwdh2H7jMw90bY8OdgGBmarYiITGbPP/+8ffzEE0+wdetWamtrMzijkdEK1ATyf//0wJDg6Q7vG7yY/yUeCn8b7+vfhIM/gYbtsPWr8P7mDM1UREQmkx/+8IesWbOG5cuX88ADDxCPx6mrq+PcuXM8+OCD1NfXc+utt/LNb35z2Ou7u7u5//77WbJkCUuXLuUnP/kJjY2NzJs3j3PnzpFIJNi0aRObN29m165dLF26lL6+Pnp6eli0aBEHDx4c9e+kFagJ4vDJLt45ZW2q6Pca3LN2Fp9cN4vA09+AjvNctPV/wtybwKM4WkRkUnikZAzv3Tns6cOHD/PMM8+wY8cO/H4/n/nMZ3j66aft95988klefPFFtm3bxrRp04a9x9e+9jVKSko4cOAAAO3t7UyZMoWHH36Yhx56iDVr1rBw4UJuvvlmAO68806+/OUv09vby7333svixYtH+csqgJowfrbP2an6lsVVPHLnIugPY3a9ZZ//x9hHOcU0/jrw73hjEThzCA78GJbdnYkpi4jIJPDSSy+xZ88eVq9eDUBvby8VFRUjusfWrVv50Y9+ZL+eMmUKAH/8x3/Mj3/8Y5588kn27dtnv/+Vr3yF1atXEwgEeOyxx0bhWwylAGoCSCRMfr7vhP36o8urrYNjr2IkogDUey/jf/f9AQALvWHuiT1jjdn2KCz6XfDljeucRURkcjBNk/vuu4+//du/TTv//e9//5LvHYlEaG5uBqw0X1FREQCtra10d3cTjUbp6+ujoKDgkj9rMAVQE8CuhjZaOvsAmBLyc/X8cuuN97fYY8pX3E7oTS+RgTh/13kTd5dsxtffDh3HYc/3Ye2nMzBzEREZV+dJs42lG264gbvuuovPf/7zVFRU0NbWRjgcHtE9brrpJh5//HG+9a1vAekpvHvuuYdZs2bxJ3/yJ/ziF78A4IEHHuBrX/sax44d4+GHH+Y73/nOqH8vBVATwM/ectJ3ty2pwu/1gGnCkZfs80WLb+W23iKe3dNMmBCbp97DbS3JP6hX/x6WfwLyC8d76iIiMsEtXLiQRx99lJtvvplEIoHf7+fxxx8f0T2+/OUv89nPfpbFixfj9Xr56le/ytSpU9m1axc7duzA6/Xyk5/8hKeeegqv14vf7+cTn/gE8Xic9evX8/LLL3P99deP6vcyTNMc1Rt+kFWrVpm7d+8et8+bDAZiCdb8zVY6Ilaq7scPrmN1XRmcfRceX2MNyiuCh4+xs7GLu7/3GwCmBhLsLn4YoyuZ+rvu/4Fr/q9MfAURERlDhw8fZsGCBZmeRtYb7udkGMYe0zRXDTdej1/luFffO2sHTzWlQVbOtArr3Ok7Zl8DXj9rLitj1tQQAK19HvbNecgZ8/p3IKZmmyIiIhdCAVSOe85VPH7n8mo8nmRjzCNbnUHzbgLAMAx+/0qnSdm3zq6E0lnWi/5OOPrymM9XRETkfJ566imWL1+e9t9nP/vZTE9rWKqBymHd/TG2Hj5tv/7o8hrrYKAHGnc4A+feZB/+3spavrH1PUwTXj3aTnjDnRTt/kfrzUPPweW3jsfURUREhrj//vu5//77Mz2NC6IVqBy2+dAp+qIJAK6oLOLySuvxTY5th3hyA+GKhVBSY19TXRpk41yrUZlpwi/ja50bvvu80ngiIiIXQAFUDnv1vbP28Z2p3k+Qnr6be8OQ635/pZPG++67BZhT6qwX/V1K44mIiFwABVA57Ng5Z9+7K1PF46YJR1wF5K70XcpHFlVSFLCyt41tvZysucV589BzYzJXERGRiUQBVI4yTTMtgLpsWrLLautRaG+wjvMKYea6IdcG/F5+Z5mzYvVsn+sJTaXxREREPpQCqBzVEYnS1RcDIOj3UlGUb71x/A1n0GVXn3eLlt9d4dRF/ej4FKXxRERkXN122210dFi73T/22GMsWLCAe+65Z0T3+P73v8+f/umfDvteYeHYNodWAJWjjrU6q0+zpoYwjGT7go5GZ9D0Ree9fvmMUgrzrTReS1c/HZfd4bypNJ6IiIyx559/ntLSUgCeeOIJtmzZwtNPP53hWV04BVA5qmG49B1AZ7NzXFLL+fi9Hq6aPdV+vSN/o/Om0ngiIjKKfvjDH7JmzRqWL1/OAw88QDwep66ujnPnzvHggw9SX1/Prbfeyje/+c1hr29ra+OjH/0oS5cu5aqrrmL//v1Dxhw7dox169axZMkSvvzlL4/1V1IfqFzlDqDqXAHUS53vsaV8Kvd2hllcMuMD77Fp3jS7j9TPTk3jjil1Vv1UKo2nnlAiIhPKkh8sGbN7H7jvwLDnDx8+zDPPPMOOHTvw+/185jOfSVtpevLJJ3nxxRfZtm0b06ZNG/YeX/3qV1mxYgXPPfccL7/8Mp/61KfYt29f2pg///M/56GHHuJTn/rUiPfauxhagcpRDa0R+7guuT1LQ2cDX+Asvyws4E+qKmj2D1//lLJxnvOH+pv6NhILPuq8qTSeiIiMgpdeeok9e/awevVqli9fzksvvUR9ff2I7vHaa6/xyU9+EoDrr7+e1tZWurq60sbs2LGDj3/84wD22LGkACpHNbhqoOqmWitQ//TWk8STpVDdHg8PH3iCaCJ63nvMnlZAdUkAgHB/jHenunaqPrIFEonRn7iIiEwqpmly3333sW/fPvbt28e7777LI488MiafZdcDjwOl8HLQcC0M6jvref7YC2nj9rce5Lv7vsvnrvzcsPcxDIMNc6fx4z1W3dTmtkoWFJRDz1mItMKp/VC9fOy+iIiIjKvzpdnG0g033MBdd93F5z//eSoqKmhrayMcDo/oHps2beLpp5/mr/7qr3jllVeYNm0axcXFaWM2bNjAj370I+69995xKUbXClQOausZIJxsYRDK81JelM+Tbz1JAmvFqDQet8f+y4F/YefJnee9lzuN99rRVph9nfOm2hmIiMglWrhwIY8++ig333wzS5cu5aabbuLkyZMjuscjjzzCnj17WLp0KV/60pf4wQ9+MGTMt7/9bR5//HGWLFnCiRMnRmv652WYpjnmH5KyatUqc/fu3eP2eRPVnsZ2fu+7rwOwoKqY79xXze/+7HcxsX6XP2w5xXdq5vIbsxuA8mA5z975LGWBsiH3Otfdz6pHra1ffB6Dgx9rI/CL5M7XdZvgD38xDt9IRETGyuHDh1mwYEGmp5H1hvs5GYaxxzTNVcON1wpUDkpvYRDiybeetIOnqyO9LOsf4G/K1toB09nes3xj9zeGvde0wnwWVlnLoLGEyZvGMufNpp0w0DPsdSIiIpOZAqgc5C4gLylp5VcNv7Jff6a9E4Dysrl8bcPX7PO/avgV3QPdw95vkyuN9/IJD1QstF7EB6Dx9dGcuoiIyHk99dRTLF++PO2/z372s5me1rAUQOUgdwF5ffQ5e/XpWqOIRQMD1hulM7i69mrmT5kPQF+8jy2NW4bcCwbVQR05B3NcT+OpDkpERMbJ/fffbz+tl/pvPHo6XQwFUDmo0e4BZXK026kpeyjiajuQ7EL+O7N/xz713/X/Pez9VteVkeez/hSOnOmmtXKD86YCKBERkSEUQOUY0zTtGijD201/oheAIn8RCztanIHJLuS3zb4Nj2H9mned2kVLdwuDBfxeVtdNsV//um8ueJObE599BzrH/mkGERGRXKIAKse09gwQ7k+2MAh12udrCiqhL/namw8F5QBUhCpYV7XOHvfL+l8Oe98Nc11dyZt6YZZzDfXbRmv6IiIiE4ICqBzjfgKvvMzZzqUmv9QZVFILrm6svzPHSeP9/OjPGa51xapZTouDPY3tg+qgFECJiIi4KYDKMe498IoKnX2Aqj1BZ1Bp+ibC18+8npAvuV9eVwOHWg8Nue/S2hL8XivoOnq2h67qTc6b9du0rYuIiIyq2267jY6ODgAee+wxFixYwD333JPhWV24Dw2gDMP4fw3DOGMYxkHXuTLDMLYYhvF+8t8pH3QPGT3uFSh/frt9XGO69v9JFpCnBH1Bbpp1k/3650d/PuS+Ab+XRdUl9uvdfVV2GtDe1kVERGSUPP/885SWWtmTJ554gi1btozLFiyj5UJWoL4P3DLo3JeAl0zTnAe8lHwt4+CYqwdUzNNqH9cOuDYNLklfgQK4c86d9vELx14gGh+6yfDKWU4cvLuxU9u6iIjIqPjhD3/ImjVrWL58OQ888ADxeJy6ujrOnTvHgw8+SH19Pbfeeivf/OY3h73+kUce4Y/+6I+49tprmT17No899tgH3vvHP/4xf/EXfwFYW7zMnj0bgPr6ejZs2DDsZ4zUh24mbJrmq4Zh1A06fRdwbfL4B8ArwMOjMiP5QO4VqJ74Wfu4pte1MeMwAdSqylVUFlRyqucUHf0dbD+xnetnXp8+ZtYU/vW1Y0CyDmrtdXDgP5Mf/Bps+otR/CYiIjLeDl8xdlu6LHjn8PCfefgwzzzzDDt27MDv9/OZz3wmbaXpySef5MUXX2Tbtm1MmzZt2HsAvPPOO2zbto1wOMzll1/OQw89xJEjR4a9980338zf//3fA7B9+3amTp3KiRMn2L59O1dfffWofN8PDaDOY7ppmqmdAE8B00dlNvKBTNN09YBK0NZ/2n6vOuwEU4NTeAAew8Mds+/gXw78C2A9jTc4gLrStQL1VnMH0d9fjz91omknxGPgvdg/GRERmYxeeukl9uzZw+rVqwHo7e2loqJixPe5/fbbyc/PJz8/n4qKCk6fPn3ee1dWVtLd3U04HKapqYlPfOITvPrqq2zfvp2Pfexjo/K9LrmI3LQe6TrvjsSGYXzaMIzdhmHsPnv27PmGyQU41z1Ad7KFQWEoQsy0jssCZYQ63T2ghgZQALdddpt9vP3EdiLRSNr704sD1E6xitH7ogne7imB4uS9BrpVByUiIiNmmib33Xef3Vn83Xff5ZFHHhnxffLz8+1jr9dLLBb7wHuvX7+ep556issvv5xNmzaxfft23njjjfFL4Z3HacMwqkzTPGkYRhVw5nwDTdP8HvA9gFWrVp030JIP594Dr3JaD6n1p5qCagi7gpvzBFDzpsxjTskcjnYepTfWy6snXuWWuvTytpWzptDcbjXn3HO8g2Wz1jtpvMbXoebKUfs+IiIyvs6XZhtLN9xwA3fddRef//znqaiooK2tjXA4/OEXXsK9Z82axaZNm/jKV77CV77yFVasWMG2bdsIBoOUlJR8+I0vwMWuQP0cuC95fB/ws1GZjXwgd/1TabGzMXBNoAzMZJuBwungy8c0TaInTmCm9sZL+kjdR+zjzQ2bh3zGKlcab8/xdqhzReraWFhEREZo4cKFPProo9x8880sXbqUm266iZMnT374hZd4702bNtHU1MTVV1+N1+tlxowZbNy4cVQ+Fy5gBcowjP/AKhifZhhGM/BV4O+A/zQM4/8EGoE/GLUZyXmd6uyzj/PyOyCZgavxhpxBJbWYpknLF/6Sruefxzt1KlPuvpspH/8f+MrL+UjdR3jirScAeLX5VSLRCCG/c727DmpPQzvmTeuxGyQcf93qB+VR+zAREblwd999N3fffXfauYaGhmGPhzM45XfwoN1Zadh7A8yZMyetcfTmzUMXDS7Fh/4/oWmaHzdNs8o0Tb9pmrWmaf6raZqtpmneYJrmPNM0bzRNs21UZyXDao84rQeinnP2cXXC3QNqBu0/fJqu558HIN7ayrknnuD962+g5eGHmdGTz7wp8wDoj/fzStMraZ9x+fQiCvK8AJzq6qPFV+v0g+pth7Pjv/wrIiKSbbSUkEM6Ik46LpJwCvJro05g1R8p5sw//MPQi6NROn/2cxruuZfbKpz+Tr9q+FXaMJ/Xw4qZ7jReB8xa7wxQGk9ERMbIU089xfLly9P+++xnP5vpaQ1LAVQOaXMFUF0xp4VBTZ9VG5WIw4l/32fXPeVfcQXV//vrBFessMfGTp3iml87HcxfO/Ea3QNOPRWkp/H2NrbDLHcd1I7R+TIiIiKD3H///fYTdan/Hn/88UxPa1gKoHKIk8KL0TlgpfAMDKqSPaDOHiim/3jyfH4+NV//B0puv526//h3Kv/6f9r3if/7T1njsbqyDiQG2NaUvllwekfytkEB1OswzGbEIiKSvYbbRF4cF/PzUQCVQ1IpPMPfgZlsvVURqiCvq4We03m0vVNgj634y78kf+5c+3Xp7/8+gUWLADD7+/nUq177vcFP462YWYqRLKs6fDJMT+l8CCQf++w+Da1HR/27iYjI2AgEArS2tiqIOg/TNGltbSUQCIzoOrWVziFtPVYA5fG7NhEurIb3tnJ6bwkkn5cr2LSJKfem72hteDxM/9LDNH7yUwBUbD/MnNlejlYb7GjZQddAF8V5xQAUB/xcPr2Id06FiSdM3jrRxfqZ6+G9F6ybNe6AaXMREZHsV1tbS3NzM2pmfX6BQIDa2uF7KJ6PAqgcEY0nCPdZncc9ea4AKlhOtLOX/k5rhcjIz6fqfz2KYRhD7hFavZqim24ivGULAA++ms8X7+4nmoiy7fg27pp7lz12xcwpvHPKanT2VlMn62e5A6jXYeV9Q+4vIiLZx+/3c9lll2V6GhOOUng5osPVwiAY6rSPa3yF9Jx22tuHVl6J/wP2GKr4yy+A39rhbtaxCGvftZZ0Bz+Nt3yG06n1raaOoXVQIiIik5gCqBzhbmGQl+9agfKGiLgDqKvWfeB98mbNouweJ7338VcSGKbJGy1v0NnvBGZLa0vt47eaO6BqGfiTNVadx6Hj+EV/FxERkVynACpHuJtoGu4aKPxpK1AFV6390HtNe+hBPMVWvVN1O1zeDDEzxsvHX7bHzKsoJOi3Cs1PdvZxuicGM133bnzjor+LiIhIrlMAlSNSBeQAcW+rfVx5qptYrxXoeAI+AgsXfui9vCUlFN92q/36mgPWPnruNJ7P62FJzaA03kzX6lbTzpF/CRERkQlCAVSOsFN4xgBRugDwGT5CBxvtMaG55Ri+C3suoOQup2B83Tsm/qjJb07+ho6+Dvv8Mlcd1P7mTpixxrlB05sX8zVEREQmBAVQOSKVwnO3MKgsqKT3kBNAFSyedcH3Cy5fjn/WTABC/bDqiEncjLP1+FZ7zLIZg+qgalaCkfyTOXMI+sMX9V1ERERynQKoHNGeaqLpbmEQqiby3hn7dWjZFRd8P8MwKLnzTvv11QeGPo23zF1I3tRBwl8IFVYzTswEnNgzsi8hIiIyQSiAyhHtwzTRXNRRQDy5MuXNj5M/b96I7ukOoJbXm5T0mLx56k3a+toAqJ0SpKwgD4CuvhgNrT1K44mIiKAAKmc4Kbw2+9z8+n77uGB6P0aobET3zJsxg+DKlQB4TdhwyCRhJtjaaKXxDMNgWa2rkLy5Y1AApUJyERGZnBRA5Qg7hecKoCoPu9J30wcgOGXIdR+m5C5XGu/Q0Kfx0uqgmgYXku+CRGLEnykiIpLrFEDliFQA5fFbT+B54ybBQ8fs9wum919UAFV8yy0YeVaabvYpmHHWZPfp3ZzrPQcMqoNq7oApl0FBuXWivxPOvXdR30dERCSXKYDKEakaKMMbAWDuSTB6rRSevyBGXmH8ogIob3Exhddfb7+++mAiLY231JXCO9TSxUDchFql8UREZHJTAJUDEgmTzt5kJ3JPHwCLG0z7/VBFP3h8kFd4Ufd3p/E2HDLBNO003tTCfGaUBQEYiCV491RYheQiIjLpKYDKAV19URImgInH2wvA4kan9qggVf9kGBd1/8KNG/GUWCtN08Iw6wzsOb2HMxGrxsqdxtvX3AEzXFu6aAVKREQmIQVQOcDexsUzAEYCTJO60877ofKLq39KMfx+CjdutF+vPGJiYrKlcQsAy12F5PubOqB6ubXiBdD6PkTaEBERmUwUQOWAVAsDw2OtPhVHoCDZwcDjS+ALJS4pgAIovPZa+/jKI9bq1uaGzQAsHVxI7g9C1TLn4uZdl/TZIiIiuUYBVA5I7YNnJNN3Va4Fn7yimJW5u9QAatNG8Fh/DnNboChisvfMXk73nGZxTTGeZHbw/TPddPfHlMYTEZFJTQFUDmjrSQ+gqtucAvK8oph1cIkBlLe0lOCKFYD1R7HiqPUZWxq3EMrzMX96EQCmCQdPdELtaudiFZKLiMgkowAqB3QMSuFVtrsDqLh1cIkBFEDhNdfYxyuPpO+N525ncKC5M30F6sQeiMcu+fNFRERyhQKoHNCWTOFhr0A5743WChRA4bVOALXsmIk3brLv7D5O9ZxiiasOav+JTiipgeJa60Q0AqcPXvLni4iI5AoFUDlgaA3U6KfwAPLnzcNXXQVAqB+uaLY+Z3PDZpbWuFegOqyD2pXOxSf2XPLni4iI5AoFUDmgvcdJ4RmmSeUYrUAZhkFR2tN4Thrviqoi/F6rkryhNUJnJAo1q5yLFUCJiMgkogAqB7S5VqCmdkFesuzJG/LizUuuRgVLz3P1yLjbGaw8Yv27/9x+2vrOcEVlsf3ewZZOqFUAJSIik5MCqBzgTuGlpe9KXZ3HR2EFCiC0Zg1GIABYT/tNT37er5t/zRJXIfn+5k6rF5ThtU6cfRf6ukZlDiIiItlOAVQOsBtpensHFZDHnRejFEB5AgEK1q2zX1+ZbGfwSvMr6XVQJzogrwAqFibPmNDy21GZg4iISLZTAJXlTNOkPdUHytOXvgJV0OcMHKUACoZvZ/DmyTeZW+m3z7/V1Gkd1FzpXHhi96jNQUREJJspgMpy3f0xYtZOwnh8vekF5MGe5JEB+SVDL75I7nYGC5rBHzWJJqKcix8gz2f9yZzo6KW1u39QHdTeUZuDiIhINlMAleVST+ABeLx95+lCXmpvwzIa/JWV5M2ZYx3HTLudwfYTv2ZhlVNIfuBEJ9S4Whk077ZalYuIiExwCqCyXHuqiSbgMXuoSGbOMAzyCkevhcFgBVddZR8vaUgGUM3bWVJTZJ8/0NwJ5VeAv8A60X0KulpGfS4iIiLZRgFUlrMDKCPK9M4YnuQCj6+iDI8vOWgsAqh1TgC14rj1pF17fztTyk7a5/ef6ASPF6pXOBeqDkpERCYBBVBZrv08LQzyq6Y6g8YggAqtWWOnBWeejFHQa312O/vsMQeak8th6kguIiKTjAKoLOfuQp7WwqDCqUUaiwDKW1xMYPFi67NNWHTcCqD2t71O0G+tSJ3q6uNMV196R/JmBVAiIjLxKYDKcudtojk16AwagwAK0uugljdafyr1nfXMr3XaJwwpJG/5LSRc/alEREQmIAVQWS61jQveQT2gynzOoLEKoFx1UCub8+zjorL37eP9zZ1QUgNF1ibERHvg7DtjMh8REZFsoQAqy9ldyD29VLlTeMWudgHBsjH57OCKFRh5VuA05XSEsi7rM7uMt+wx+5s7rIPB7QxEREQmMAVQWS6Vwgsmuijrts4lvB78gX5n0BitQHkCAYIrnU7jqXYGxyMHwWN9/oETnZimmR5AqZBcREpZvqsAACAASURBVEQmOAVQWa4tWURe3d1qn4tML8YY6HAGjVEABVBwlbMv3vqTVg+ouBmnqPg4AOe6BzjZ2acASkREJhUFUFkutQJVE3YCpmj1NOhtdwaNZQDlqoO64ljU7jQ+rbzJPr+/uTPZC8qwTpx5GwZ6EBERmagUQGW5tuRGwjVdXfa5xIzKcQugAosW4SmyVp6C7RG7lUI84BSSHzjRAYFiqys5gJmAln2DbyUiIjJhKIDKYr0DcfpjCQBqupwVHc/M2nELoAyvl9DaNfbrZQ3Wvx2xBvBEgOQKFCiNJyIik4YCqCzm3gevprPXPs6bORP6Op2BgZIxnYe7DmpdSyEAJia+0DHAVUie1pFcT+KJiMjEpQAqi6XSdwBTw1H7uKCqHEi2McgvAa+PseSug5pT34uRsD47WGIFUB2RKM3tvYNWoPaO6ZxEREQySQFUFuvstYImTyJOScTp7l1U6t7GpXTM55E3ezbe8mkA+CMDzDpjnQ8U1dtj3mrugIqF4Et2SO9sgvDpMZ+biIhIJiiAymLhvhgApf3deJILTp0hKDZcg8aw/inFMAwKVjt1UEuarAn0GS0Y3jCQ3FjY64eqZc6FqoMSEZEJSgFUFuvptwKosn6nhUF7IRRGnb3oxiOAAgitcQKoq04W2sfeAmsVyi4kr3VtLKw6KBERmaAUQGWxyIAVQE3td5pohov9eNwF5OMVQLmexKs7FrHroLyhowAcPNFJIqGO5CIiMjkogMpi3f1W3ZM7gOopyR+3FgZueXV1+MrLAasOqi5ZB5VXaAVQ4f4YDa09QwvJE4lxmZ+IiMh4UgCVxVIpvKn9TsDUXxrMSABlGEZaGm9Zk9c68Ldi+Kz5HDjRCaUzoaA8OdkuaH1/8K1ERERyngKoLNadCqD6nC7k0bKijARQkJ7GS6+Dslah9jd3gmEojSciIhOeAqgslqqBKusL2+cSU0szFkAVuFagZtZ323VQvpBVSH7A7kjuKiRvViG5iIhMPAqgslhPqgaq19nGxSgvy1gA5Z81C19FBQC+3gHqkm2eUk/iHWzpJJ4woeZK5yKtQImIyASkACqLpVJ4ZZGIfc5bXpGxAGpwHdTyZB2Ux9+B4esiMhDn6Nnu9BTe6YMQ7R18KxERkZymACqLRQZieBNxSvusLV0SQH7F9IwFUJBeB7X6ZMg+9gYbgWQdVLAUps6z3kjE4NSBcZ2jiIjIWFMAlcW6++NMcdU/dRZAcTBzNVCQXgc161gET6ofVDKAOtCcbPrpXoVSHZSIiEwwCqCyWE9/jKmuppntRVDsL4I+pzM5gZJxnZN/5kx806dbx70DXHbKOu8NHgfgLXUkFxGRSUABVBazAiinhUF7oUGRN99KiwF488AfGNc5GYaRlsZbeNxagfIEToAR5e2WLvpjcRWSi4jIhKYAKov1DMQocwVQbYVQbPicAXmFw1w19txpvFUtVgBneOJ4Ai0MxBMcPhmG6UusAA+gvQF6Woe5k4iISG5SAJWlYvEEfdHEkBWoYvevLD8zAZT7Sbw5jQND6qD2HW8HXx5ULnUu0iqUiIhMIAqgslTPgNUDyr0C1V4ExabhDMorGu9pAeCfMQNfVZU1hb6Yqw7KCqCGr4NSACUiIhOHAqgs5XQhd4rI2wqhMB53BmVoBcowDArWrLZfL0rWQXlDxwGTfU3DPImnQnIREZlAFEBlKXsjYVcA1VcSxB9zNaXMz8wKFKSn8ZYet/6MPL4whr+dY+d66IgMDN0TzzTHe5oiIiJjQgFUluruH5rCi00thn6nL1SmisgBQmvX2sdXNJt446k6KKudwb6mDiibDYFSa1BvO7TVj/s8RURExoICqCzV0x/DH49RMmCtOMUN8EwphYFuZ1CGUngA/poafNXJOqj++JA6qH1NHWAYg1ah9o73NEVERMaEAqgs1dMfY4pr9amjEAoDxdDvCqAyVEQOyTqo1U4az66Dcq9AgRpqiojIhKQAKkv1DAxuognFecVZswIF6Wm8RY2phponwRjgraYOTNMcWgclIiIyASiAylLd/fH0bVwKDSuAypIaKEgvJF9wArxxE8NI4A020R6J0tgaSQ+gTu6H2EAGZioiIjK6FEBlqUj/MF3I8wcFUBl8Cg8gr7YGf3W1NZUBk9knrfNpabyCaVA6y3oj3g+nD2ZiqiIiIqNKAVSWGrIPXpExTAovswEUDErjHR/UkXzYOiil8UREJPcpgMpS3f3x9C7khVCUVzSoiDyzKTxIT+PZGwsHmzh/Q00FUCIikvsUQGWpwStQbakAKouKyIG0juQLkv2gPL4eDH87b7d00R+LQ41rBapZT+KJiEjuUwCVpayn8FxF5EUGIV8oq4rIweoH5a+tBSA/CnPsOqgmBuIJDp8MQ9VS8PisN1rfh96ODM1WRERkdCiAylI9/THKetNTeEMCqCyogYL0NJ5dBxVIFpIfbwd/EKYvci5oUUNNERHJbQqgstRAd4TCWB8AMQ+EgxDyh7KuiBwg5N5YuDFVSN4EwN7jqoMSEZGJRwFUlvJ2tNrH7YWAYRD0BbOuiBygYNC+eP6YiSfQAsTYe7zdeiOtDkoBlIiI5DYFUFkqr6PNPm5PxkkhTx7EepNnDcgrGP+JDcNfVUXeLKvXU14M5p8wMTwxPIFTNLf3crqrb+gKlGlmaLYiIiKXTgFUlsrvdAVQRQYAQXfQkVdobdabJULrrrKPFzekp/H2NLbDtPnO3n09Z6CzadznKCIiMloUQGWpULjdPm5LrUAlEs6ALGhh4FZw1Tr7eEkqgAq4AiiPB2pWOBeoDkpERHKYAqgsFE+YFPc4j/q3F1orTYFYvzMoSwrIU0Jr19grYnNOQrDfTDbUhN2NqTooVxpP/aBERCSHKYDKQpGBQdu4FELQF8QzEHEGZUkBeYpvyhQCCxYA4DWtruTe/LPgiXDoRCd90UENNU+olYGIiOQuBVBZqGfQNi5tRckeUAPuHlDZFUBBeh2UncYLNhNLmOxv7kxfgTq5D+Kx8Z6iiIjIqFAAlYV6BmJMcTXM7CwYroVBdqXwIL0OanAh+e7GNiiuguIaa0A0AmcPj/scRURERsMlBVCGYXzeMIxDhmEcNAzjPwzDCIzWxCaznv4Yxf099uuu0HBNNLNwBWrlleD3AzDzHJR0m3Yh+V67DupK5wIVkouISI666ADKMIwa4HPAKtM0FwNe4H+M1sQms+7eAYpc9U7hYGobl+xrounmCYUILVtmv17cmCokN9nT2I5pmtpYWEREJoRLTeH5gKBhGD4gBLRc+pQk0taJFysF1pMPcW8qhefURWXbU3gpg+ugPL4eDH8b7ZEo9ed6BjXUVCG5iIjkposOoEzTPAF8HTgOnAQ6TdPcPFoTm8wGWp0mmuGg9W8upPAACtatt48XN5pgmukNNatXgJH8szt7OH1VTUREJEdcSgpvCnAXcBlQDRQYhnHvMOM+bRjGbsMwdp89e/biZzqJDLQ6++B1hax/h6bwsnMFKrhkMZ6QNemKTpje4dpYuLHdCvzKr7AGmwnraTwREZEccykpvBuBY6ZpnjVNMwr8FFg/eJBpmt8zTXOVaZqrysvLL+HjJo9Yu9OFPBxMbuPiC+bECpTh9xNavdp+vaTBKSRXQ00REZkoLiWAOg5cZRhGyDAMA7gB0HPpoyDR4XQhD6dWoPwhcLU2yMYi8pQhdVCBFiDGkTPddEQGhm4sLCIikmMupQZqJ/AssBc4kLzX90ZpXpObO4BK1UD5cqMGCtLroJY0mHiI4gmcBGDv8XaodXckVwAlIiK555KewjNN86umaV5hmuZi0zQ/aZpm/4dfJR/GE+60j7tCrhSeewUqv3i8p3XB8ufPw5dM1xb2WXvjpeqgdjW0Q/kC8CeX1rpOQNfJTE1VRETkoqgTeRZKD6Csf60UXnb3gUoxDIOCjRvt18vrnSfxdh1rA68PqpY7F5xQHZSIiOQWBVBZKC/s9HtKpfBypYg8pWDjBvt42bGEXUj+VnOHtbFwrasOqunN8Z6eiIjIJVEAlYXye1wBVDKFlwudyN0K1q8Hw5r7vBYoSpwFT4Ro3GRfUwfMWOsMbt6VoVmKiIhcHAVQWSgQcWqdutJWoNw1UNnZByrFN2UKgSVLAPCYVlPNVBrvzWNtULvGGXxiL8QGMjFNERGRi6IAKguF+pyVJvspPMNrNZ4E8OaD15+BmY1MoSuNl1YH1dAGRdOhdJb1ZrwfTh3IxBRFREQuigKoLGNGo4QGegGIG9CTCqASCWdQlq8+pbgLyZfVm3gDxwFrS5dYPAEzXKtQTTvHe3oiIiIXTQFUlom7ekB1BwzMZB1RMC2Ayu76p5Tg0qVQWADAtDDU9R4HTCIDcQ61dA2qg1IhuYiI5A4FUFkm2uZs45LqAQUQSsScQVm6D95ghs9Hoaup5rKGCIbf2ufPqoNytnzRk3giIpJLFEBlmciZc/ZxOGjax6F43BmUIytQAIWbBqXxknVQO4+1wfTF6Q01O5szMUUREZERUwCVZSJnW+3j1D54BgaBqKvJe5a3MHArdNVBLWwyCfobANjd2EbC8Kbvi6dVKBERyREKoLJM37mhAVTQF8SI9jiDcqSIHMBfXU1sZiUAeTFY3n4UgI5IlPfPdKcXkqsflIiI5AgFUFlmwFUDZbcw8Ieg32mumUspPIDijVfbx0ubzoJh1XO92TCoH5SexBMRkRyhACrLRNva7OP0jYTdXchzZwUKYOp1N9rHy+vjePKtzYOHFJKf3A/R3vGenoiIyIgpgMoy7jYGqS7kIV8op/bBGyy0ejWxPC8Ata1QE30bsDYWNkNlMHWuNTARhZZ9mZqmiIjIBVMAlWXMDlcKL1kDZaXwcmcfvME8gQCRpXPs11edtQKoU119NLX1qh+UiIjkHAVQWcbo7LSPw0FXCi9tH7zcCqAASq+7wT5e1XQasFo0WHVQ6gclIiK5RQFUlvGGnQCqK7UC5Ru0ApVfPM6zunR1t/6efbzgeIygkaqDak1fgWp6E0xz8OUiIiJZRQFUlvGF3StQ1r9WCs+1ApVjKTyA/OoaztVY8/bH4coOa6VpV0M7lF/hBIU9Z6D9WKamKSIickEUQGWRRG8v3ugAAANeD3151nkrhZe7ReQpfWsW2cdrT70HwLFzPZzpGUjvB9X4xnhPTUREZEQUQGWReLtrH7z8PEhuJDwkhZeDK1AA5TfeYh+vbDpnp+p2HWuHmeucgcdfH++piYiIjIgCqCwScwdQAb99HPQPLiLPrT5QKQs23WWnJcu6E8zpfh9I1kHNcjYd1gqUiIhkOwVQWSSe1oXcax9PlBWo/LwgjQun2q/XnrPqoHYea4PqK8GbzFm2HYXw6UxMUURE5IIogMoi8Q73CpQTQA2tgcrNFSiAxLrl9vGak9a+eO+eDtMZ9ULNKmfgca1CiYhI9lIAlUXcNVDhoPOrCXnzIdZnvTA84A+O99RGTc31d5CwSruYdyZMSX83pgm7G9tglrsOSgGUiIhkLwVQWSSWFkAZ9nHIdI7JK7KLy3PR0rnrebfGmr8HWHXmIJBsqDnTXQe1IwOzExERuTAKoLKIewWqM+ScD7obS+ZoC4OU4rximpaU26/Xnt0LJDcWnrHGWmEDOHUQ+jqHu4WIiEjGKYDKIvF2ZyPhcMgJmkLuACpHC8jdjI1Oz6eVJxvxx2McaO6k11MA0xcn3zG1rYuIiGQtBVBZJK0GqiBhH4cSznGur0ABzFtxHadKreNQNM6Sc0eJJUx+e7wdZm1wBjaqH5SIiGQnBVBZJNraZh93h5ygKRiPOYNy+Am8lBXTr2T3PKeO66pTB4BkHZQKyUVEJAcogMoiaUXkBU7QFIpFnUETIIVXWVBJw9IK+/VVpw+CaVp1UO6O5Cf2QLQvAzMUERH5YAqgsoRpmpidrhqoggH7OBR3jifCChRA2Zr1dAes4/JIN3M6T7D3eDsDgWkwda71RnwAWvZmbpIiIiLnoQAqSyTCYYjHAYj48on5rWMDg/wB1yrMBFiBAlhTu469c5w03rqTh+iLJjhwojN9FUp1UCIikoUUQGWJtBYGeU4Pg5A/hBF1dyGfIAFU5Rp2zXfXQVn9oHYea1UhuYiIZD0FUFnCHUB15TudxofsgzdBUnjTC6bTsayOaHLHmjmdJ6mItFl1UO5C8qadEI8OfxMREZEMUQCVJWJt7gAqYB8P2Qcvb2IEUADL69ZxcJazCrX21NvsbmgnVjQDSmZYJwe6oWVfhmYoIiIyPAVQWSJtBSqQbx+H/CHoDzsDJ0gKD2Bt1dr0dgYnD9HdH+PtU2G47Gpn4LFfZ2B2IiIi56cAKkvEO1wtDPLz7OMhKbwJUkQOsHr6avbOdf4El547Sijaa6Xx3AFUw/YMzE5EROT8FEBlibQi8oDfPrZSeBNzBao0UEpF3QKOVlqvfWaC1aff4Tf1bVC3yRl4/DcQ68/MJEVERIahACpLuJtodgV99nHIH4KBHmfgBFqBAutpvN3znD/DtafeZldDG4miaiibY52M9UHzrgzNUEREZCgFUFnCvZFwV8AJoKwVKHcAVTCe0xpza6vWprUzWH3qMN09fbx7enAd1KsZmJ2IiMjwFEBlCXcKrzvo/FqsACriDJxgAdTK6StpqfBxpsR6XRjrY0lrPTvrWxVAiYhI1lIAlSXinZ32cbfTxcBK4UVdK1D+iRVAhfwhllQsHfI03s5jg+qgmnenr8SJiIhkkAKoLBHv6rKPu4OmfRzyDa6BmlgBFKTqoNIDqDfrWzELpkHFQutkImoVk4uIiGQBBVBZwDRNEq4VqJ6AE0AFvQGriBoAA/xBJpq1VWs5PMOgJ9n+anpvO8UnGzl6tltpPBERyUoKoLKA2duLGbW2Kxnw+BjIi9vvhQyvMzCvAAxj8OU5b1n5Mvx5QX47J30V6jf1bQqgREQkKymAygLu9F04L4ThGbBfpwVQ/hATUZ43j5WVK9nlTuOdOpTcF289kDx/ch/0dQ5/ExERkXGkACoLpBWQ+4PpAZTpWnGagPVPKRurN7JvtkEs+Rc5v6OZ9w4ewQyUQtUy66SZgMbXMzdJERGRJAVQWcAdQIXzQuBxum4HTaceaiIHUBtqNtAbMDg00wkY5xzZR2NrJD2NV6998UREJPMUQGWBhPsJvCErUJMjgKorrqO6oDrtaby1J5NpvMuucQbWvzL+kxMRERlEAVQWSFuB8ocgLYBKOAMnaA0UgGEYbKjZkBZALT93hD3vNMOsdeBNPqJ39jB0NmdoliIiIhYFUFkg3ulagcpLX4EKxp0n8ibyChRYabzWEoNj063X/kSc3h07rO89a50z8OjLmZmgiIhIkgKoLDCkiNxwrUBNogBqbeVafIYvbRXq8iO/pbk9AnNucAYeeSkDsxMREXEogMoC8a7zF5GH4lFn4ARO4QEU5hWyrGIZu+Y5f5arTx/mzffPwFxXAFX/CiTiQ28gIiIyThRAZYFE2gpUAMNjBQcew0NetM8ZOMFXoAA21mykYTr25sJF0V6Ov/yataVLUZV1sq8DTuzN3CRFRGTSUwCVBdw1UOF8v30c8oUwor3OwEkQQG2o3gCGkdZUM//N16wO7O403lGl8UREJHMUQGWBtI2E8332sbWRcLczcBIEUJeXXU5ZoIxd850AanH9Pk53RGDu9c7AI1szMDsRERGLAqgskFZEnu9s3RL0ByEacQZO8BoosNKWG6o38M4Mg67kvsnT+jrZ99JvYPZ12Nu6nNgDve0Zm6eIiExuCqCyQFoNVMD5lVgrUD3OwLzC8ZxWxmyo2UDCY7BnrrMK1bV1K4TKoOZK64SZUFNNERHJGAVQGWYmEmkpvEjACRqCvuCgAGrir0ABrKteh4GRlsabuu831sHcG52BamcgIiIZogAqwxLd3ZDcriXiyyfudR7PD/oHBVD+iV8DBVAWKGNp+VL2X2bQnywJq2o/yelD7w0qJH/Z/tmJiIiMJwVQGeZefQoP3gfPF0qvgZoEReQp19Rew4DfYN9sZxXq6H/9EmpWQn6yx0HXCTj7boZmKCIik5kCqAyLd7jqnwY30RxSAzU5UngAV9deDZCWxotvfwW8Ppjt2lz4yJZxnpmIiIgCqIxLuLuQD1qBGloDNTmKyAHmT5lPZUEle+cYxJMxVFnj+0TPnIF5NzkD3/tVZiYoIiKTmgKoDEvfBy+UHkBNwjYGKYZhcE3tNXSHDA7PtCIoDyanXtgC8z7iDGx8Xe0MRERk3CmAyrC0LuR5IfA4e98NXYGaPDVQ4KTx3nSl8U6/8Csomm7VQgGYcXhfTTVFRGR8KYDKsPQVqCCG4Soi907uAGpN5RoC3kDati6BA3uJd3fD5bc6A997IQOzExGRyUwBVIbF3TVQg1agAoYXSD6m7wuAx8tkEvAFuKrqKlpLDOorrXPeeJzuX/8a5rsCqPe3Qjw6/E1ERETGgAKoDEu498EbtAIVwFl5mUz1T27XzLCeuNs1z/lTPfPCZpi+CEpmWif6O61aKBERkXGiACrD3G0MhtRAuQOoSfQEntummk0AvHm587Pof+01EtEoXH6LM/BdpfFERGT8KIDKsPjgFSjXU3gBd5PtSdQDym16wXQWlC2gaRqcKrXOefsiRHbuTK+Devd5dSUXEZFxowAqw9KKyPNCYLhWoBIJZ+AkTeFBMo1npO+NF96yBWZthLwi60RHI5x9J0MzFBGRyUYBVIbFhzTSdAVQpiuAmmRP4LldW3stAG9e7vy5dmx9CdPjg7nXOwOVxhMRkXGiACrDEp3uFF4I3Cm8uLOx8GQOoBZOXUhlQSXvVUNHaiGurY3et96Cy29zBiqAEhGRcaIAKoPMaJREj9XnKWEYRPz56U/hxWPO4EkcQBmGwY0zb8T0GOxx9YQKb90K824GI/ln3LwLus9maJYiIjKZKIDKoHg4bB/3+IOYhif9KbyEK4CaxDVQADfOuhFI70oe3rIVMzgFZlyVPGNaxeQiIiJjTAFUBrlbGHT7gwDpe+HFnOPJ2sYgZXn5csoCZRysM+jNs85Fjx9n4OhRWHCHM/DwzzMzQRERmVQUQGVQwlVA3uUPAWZaEXl+tN8ZPEnbGKR4PV5umHkDUZ/BvtmD0ngLfscZWP9r6O3IwAxFRGQyUQCVQWk9oPKCYDgpu3xvPt5oxBk8iWugUoZL43Vt3gylM6F6hXUiEYX3XszE9EREZBJRAJVB7h5QYX8ovYmmLwDuAMqvAGp15WqK/MXsnWsQTW4L2P/2YQaammDBnc7At3+WmQmKiMikoQAqg+Kdg1egXBsJewMw0OMM1goUfo+f62ZeS2++wf46Vxpv8xZYeJcz8MhL0B8e5g4iIiKjQwFUBsU7nVqdwStQQV9wUAA1uWugUm6caaXxdl7hDqA2w9Q5MH2xdSLeD+9vzsT0RERkklAAlUGJQfvg8UEBlFJ4AKyvWU++J8juuQbxZAzV+9ZbRE+dGpTG09N4IiIydhRAZVBaG4O8EIY7hTe4BkopPMAqrr+69mq6QwaHZqX3hGKhK4B6fwsMRIa5g4iIyKVTAJVB7qfwwv5QehNNpfDO65bLbgZg5+WD0njlV8DUedaJaA8cfSkT0xMRkUlAAVQGDW5jkPYU3pAi8sndSNPtmhnXkO8p4M35BqntliN79hBra0svJlcaT0RExogCqAwaXETOB6XwJvlWLm753nyuq72ZzkKDd2uTJxMJwltfSk/jvfcixPqHvYeIiMilUACVQYnO869AWSm8bmewaqDS3LPoYwDsvNz5Ew5v3gyVS2FKnXWivwuOvpyB2YmIyESnACqD0htppveBsgIoFZGfz7LyZRR4qtLqoHp27rTSogs/6gw89F8ZmJ2IiEx0lxRAGYZRahjGs4ZhvGMYxmHDMNaN1sQmukRfH+aAteKU8Pno9+al10B5/Na2JAAeH3jzMjHNrGUYBldX3UJricGRquTJWIzwy9tg8cecge88D9G+jMxRREQmrktdgfo28KJpmlcAy4DDlz6lycHdhXwgWAiGkfYUXsBw/Wr8Bdb7kuaBK/8A0zTS03gvvmil8cpmWycGwnBkS4ZmKCIiE9VFB1CGYZQAVwP/CmCa5oBpmh0ffJWkuAvI+4NWes4wXDVQeJ3BamEwrDlltRSal/OGqyt59+uvEw+HYZFrFUppPBERGWWXsgJ1GXAWeMowjN8ahvEvhmGoUOcCubuQ9wWSPzb3ChSuFSfVP53X+opbODPF4Ghl8kQ0Svjll9PTeO++qKaaIiIyqi4lgPIBVwLfNU1zBdADfGnwIMMwPm0Yxm7DMHafPXv2Ej5uYnEXkEfykytQ7qfwTNMZrBYG5/VHK+7EjOfxmytcabwXXoSKhTBtvnUi2qO98UREZFRdSgDVDDSbprkz+fpZrIAqjWma3zNNc5VpmqvKy8sv4eMmFncNVCSVonM/heeKn9RE8/wWVU0jMHDlBaTxfpqB2YmIyER10QGUaZqngCbDMC5PnroBeHtUZjUJxLvc++AFgfQVqEDCFUGpBuq8DMPgmso7h6bxXnoZFv2uM/C9zdDfPew9RERERupSn8L7M+BpwzD2A8uBv7n0KU0O6T2gkgGSuwYqEXMGqwbqA/0fS9cT67ksPY334otQcYWVygOI9VqdyUVEREbBJQVQpmnuS6bnlpqm+VHTNNtHa2ITnbsLeZc/uQLlTuElEs5gvwKoD7Jq1hT83demp/F27LCaauppPBERGQPqRJ4h7hWoDm/AOnAXkcedYEorUB/M5/Vw/cxrOVUwzUnjxWJD03jvb4G+rmHvISIiMhIKoDIk7mpj0J4MoNJqoGLuAEo1UB/mxoWVDLRt5I0Fzp9014svwLS5ULnEOhHvh3dfyNAMRURkIlEAlSHuIvJ2T3IFyp3CiznBlJ7C+3BXzy+H8CremBe0zzlpPNcqlJ7GExGRUaAAKkMSXWH7uNWw9rlLEE5EjAAAIABJREFUW4GKuwIo9YH6UMUBP2vrqmg219lpPCMWH5rGO/IS9KphvoiIXBoFUBniTuF1+oJAAsPjPHmX7+6crRTeBblxQQXR9vW8foWzDU7zz//T2hevarl1IhGFd36ZoRmKiMhEoQAqA0zTTAuguv1BMJzgKegL4on2OhcohXdBblgwHTNWzGs1i52Tb+6zftaL9TSeiIiMHgVQGWD29UE0We+Ul0fU609P33kDMNDjXKAU3gWZURbiisoimqK3cKTSamngjZu8/dwP0tN49dsg0pahWYqIyESgACoD3KtPFBZZ/7oDKF/A2r8tRW0MLtjNiyoxB8rZcVm1fa7pZz+C0plQs8o6kYjB4f/O0AxFRGQiUACVAQlXAGUWWQFUWhNNXxDSaqAUQF2oWxZZFeS/nnK7fW7G4TYO1L+hNJ6IiIwaBVAZ4F6BSoSS9U2DV6AGtAJ1MRZUFTGzLMTJvPm8X26lPn0JeOXf/wEW3uUMPPYq9JzL0CxFRCTXKYDKgLhrG5d4gRVAGe598LyDUniqgbpghmFwy2JrFWp71Sr7fNkb73Ao2gkzrrJOmHF4+2eZmKKIiEwACqAyIBF2AqhoMLm65E7h+YODVqD0FN5IfCSZxnt1+gb73NJjJk+98Y9K44mIyKhQAJUB7hWoaDC1AuXaB887uAZKK1AjsWJGKRVF+ZwumMp7U6xgypeAvle28271YiC56XDjDgifztxERUQkZymAygB3DVR/ILkCldbGIB9iqT5QBviCyIXzeAx7FWp79Ur7/Lp3TH7Q8EuYlVyZMhNw+OeZmKKIiOQ4BVAZ4E7h9eZbq0tpT+F5/M5gfwg8+jWNlF0HVb3UPrf0mMmrbz/Pqfk3OAMPam88EREZOf0/cwa4U3i9gWR6zr0CZThbkSh9d3HWXFZGachvpfFKawErjbf8vSj/nxEGI/mnf/wN6GrJ4ExFRCQXKYDKgHjY2Ug4kmel59KewnP/WtTC4KL4vR5uXDAdgFdrltnn171j8uyx5+mqW5c8Y+ppPBERGTEFUBmQ6Oy0j7v9yfomVwovZLh+LX4FUBcr1VTztUFpPCPcw39WzHIGKo0nIiIjpAAqA9xF5OFkj6e0vfBM12CtQF20jfOmUZDn5XTBVN4tnQFYabxV75s83fU2/Z5kqrT5TehoyuBMRUQk1yiAygB3Cq/LG7AOzhtAqQbqYgX8Xm5IpvG21zirUOsOm5zra+MXdcudwW8/N97TExGRHKYAKgPcKbzOZACV9hSe6Yqg1ETzkty+tAoYlMZrMCnoNfm3vAT2T1ppPBERGQEFUOPMjMVIRJJNMj0eOlItC9xF5ImEc4G2cbkk18wvP28ar76/lX3B5M+3ZS+0N2RuoiIiklMUQI0zd/rOU1REX9RaAzEMVyfyRMy5QDVQlyTg93LTwuHTeAA/rZrjDNYqlIiIXCAFUOPMnb7zFhfTG40Dg9oYxOPOBQqgLtltS6w03vZqp51BKo33KyNCj5Hc2uWQAigREbkwCqDGmXsFyltURGQgudrk3gsv7gRTSuFduqvnl1OY7+NMQVlaGm/1+ya9iSi/Kiq2Bp46AGffy+BMRUQkVyiAGmfuLuSekmL6ola9k7uIPBB3gimtQF2686Xxrkql8aZVOYMP/mRc5yYiIrlJAdQ4S3S5U3glw69ARRVAjbYPSuO9ZUao9/uskwefBfdTkCIiIsNQADXO4l2uFF5x0bA1UMFYv3OBAqhRsWneNIrOk8YD+K+SKdbA1iNwan+mpikiIjlCAdQ4c3chN4qcFB6up/AC0T7nAtVAjYr0NJ6zCpVK4/28uBg7hFUaT0REPoQCqHGWCDsBlFmQapIZx/AkV6IwyBuIOBeokeaoSTXV3O5qqrksmcZrM6O8GkruS3jwp+DuxSUiIjKIAqhx5i4ij6UCKI/T9ynoC2JEe50LtJXLqNk4TBrP60rjPVdSag3sbILmXZmapoiI5AAFUOPMncKLBq0Ayt1EM+ALwECPc4FqoEZNvs/LTYuGpvFSTTVfC+TR6Un2hDr47LjPT0REcocCqHGWSAugksGR+wk8XxCirgDKrwBqNN0xTBov9TReDJOXQ8kVv0P/BfHYcLcQERFRADXe3CtQ/QErOEp7As8X1ArUGNo4t5yigJXGe2fK0DTeC6mn8XrOQsOrmZqmiIhkOQVQ4yzuKiLvCyRXO9wpPG8A0orIVQM1mvJ8Hm5eWAnAa9VD03g78zy0epL/s9j/43Gfn4iI5AYFUOMs4Soi700GR2n74PkCMNDtXKAU3qiz03g17jQeFPSaJIAtBcmg9fB/pwezIiIiSQqgxpFpmml74fXkJR+bd6fwvPlAshO2Nx+8vnGc4eSwYe40igM+zoTcaTyTNe8l03ilU62BA2F474VMTVNERLKYAqhxlOiJQDzZ7ykYJGJaP/60p/AMV8Ck9N2YyPN5uHnRMGm8d6wAaq/P5JTXa51UGk9ERIahAGocpe+DV2xv45L2FJ7hdS5QE80xc/swabwlDVYaD2BzKo13ZAv0tP7/7N13eBTl9sDx72xLT0hIQu/SQbqCYJefBXtBRVHvxV4REQVFERTFgnoVRbFdKzZQ5IqAjSZFQDqIUiIlkEr69vn9MZuZWdhQs5t2Ps9znzt1eUeScHLeM+eN9PCEEEJUcxJARZD5DTxrYiJOd4h18CymDJQs4xI2/dukkhRjP2Qar3fgbbwfktO0C/1e2DSzqoYphBCimpIAKoLMAZQlMZHSQAAV9BYeinGDtDAIG4fNwvmBpppLTD2hTvlL+//1Fi+7bDKNJ4QQIjQJoCLIf1AGqnwKL+gtPFUCqEgZdHJjAJY27Kwf674T7B4tCzU3PjCFumsZ5O+M8OiEEEJUZxJARZCv0HgDz5qYQJk70OlaMU3hSQYqYvq3qU/9OAd7EtLZFa9N2dndfk7eGXgbLznduHi9ZKGEEEIYJICKIJ+piNySmGTKQJmm8FTVuEFqoMLKZrXoPaGWNTKyUKf+rX1bbMXFNnugJm3dF2D+uxFCCFGnSQAVQQdP4ZW6Dw2gYvx+4wbJQIXdZT2aALC0YRf92CnbLCj+QDF5YmBpl5ytsHd1xMcnhBCiepIAKoIOnsJzlrcxME/hSQAVUT2a1aN5Six/pjQnLyoBgNgiN+32aud/qJeCnnda81mVjFEIIUT1IwFUBB3VFJ7fZ9wgU3hhpygKl3VvjF+xsLxhJ/14v7+1N/B2+sv402HXDm74CryuqhimEEKIakYCqAjymzNQSaY2Bua38HzGtmSgIuOy7trbeOY6qP7b7fr2nBStToqyfNj6Q0THJoQQonqSACqCghppJiRQVl4DZZ7CkwAq4k5KT6Bz40TWpLXFadUCp6T9JTTODdRBxcfKNJ4QQoggEkBFUEVTeEFLuXglgKoKl3dvgttqZ1V6e/3YgG0OAPb6SlkXpW3z93wozq6KIQohhKhGJICKIP8hfaBCNNI019hIDVTEXNKtMYoSPI135k7jv/8PDdtoG36v9IQSQgghAVQkHbwWXlmIpVxiPE7jBllMOGIaJkXTt1V9VjTohC/QzDR1ex5JJYGu5A7Qy/vXflo1gxRCCFFtSAAVIX63G9UZCI5sNpTY2NBLuXhMGSiHZKAi6fIejSmMimNT/VYAKKrK6YEsVLa3hFVxWpsD9q3X/ieEEKLOkgAqQvwHFZB7/SreQLPGoBood4lxk9RARdRFXRsRbbewzNTO4NzdSfr2d43bGRdLMbkQQtRpEkBFyMHTd3oLA3woitY806pYsXlKjZvsEkBFUkK0nfM7N2S5qQ6q8aZs7N7ANJ6/gBIlsFbhus/B6w71MUIIIeoACaAixJyBsiQmGl3ITdN3MbYYFLcpgJIpvIi7smdT9sSnsTsuFQDF6eK8HK0PVJnfzdxUbekXSnOkJ5QQQtRhEkBFSEUZqKAu5LZoCJrCkyLySBtwUioNEqOCupJflJmub89ISTMuXv1hJIcmhBCiGpEAKkJ8BaYAKin0G3jR1oMCKGljEHFWi8LlPZqwwhRANVq7Bxva0i5r3blst9u0E9t+goI9VTFMIYQQVUwCqAjxFZmm8BISKfN4geA38GJs0eAP7CtWsEVFdIxCc3XPpmys34piWzQA/sz9XGnprZ+f2bSjtqH6YY20NBBCiLpIAqgI8R/SA0orHA96A8/iMG5wxEF5wbKIqLYNEujcPIVVDTroxy7MTNW3Z9m86GHvHx+C3x/ZAQohhKhyEkBFiO+QhYQDGSjTOnjRFmMBW2lhULWu6tk0qA6q/qqdpMdqtVB53hIWJgUCqgP/wM6FVTFEIYQQVUgCqAgJWgcvITHkOnjRFptxg9Q/ValLuzVmbaMOeldy57p1XJ06UD8/s2EL42IpJhdCiDpHAqgI8ZuLyBMT9DYG5rfwYhVTACUZqCqVHOegT7dWbKrfUjugqpyfabyBt8idQ5ZVKyxn82wozYv8IIUQQlQZCaAiJKiNQVJSyDYGMYrVuEECqCo3uHezoLfxbEvX0qdhHwD8qExvHFhg2OeCdV9UxRCFEEJUEQmgIsQX1EgzyZjCMy8kbP7rkACqyp3ZLo2/2nTX94sWLea6Vlfr+19EQWl5of+qD0BVIzxCIYQQVUUCqAjxFRzQt631kvQ+UEFTeJjeupMaqCpns1o47exeZMbWB8DiLKPv/niaxGvdyAt8TmYlJWsXZ2+GXcuraqhCCCEiTAKoCAmugTI10jRP4ZkTGJKBqhYG92ke9DZe7vxfGNppqL7/Yf1Uylc1ZOX7kR2cEEKIKiMBVASoHg/+kkCHcUXBEh9PaYgicgmgqp9WqXEUdD9F38//6Rcub3M5CY4EAHb5nfwaG6Od3DhTismFEKKOkAAqAnxFph5QiYkoFgvOUBkov8+4Sabwqo0+l51LaaArfEzufqw79zC43WD9/H/TtMWG8blg7WdVMUQhhBARJgFUBPgKTD2gkpIA9CJyxVREHmvuaC0LCVcbF/ZoxtqGRlfyLTPnMKTjEGyBvl1/WLysjQp0kV/5vhSTCyFEHSABVAT4TQGUNRBAhWxj4DNloBySgaouYh02fH0H6Pv5P/1Cemw6F7W6SD/23+QUbSP3L9i5ONJDFEIIEWESQEWA76B18ICQnchjfMa21EBVL32uHYQ/8JZk2j9bOZCZxU2dbtLP/xTjYKct0Ah1lRSTCyFEbScBVAT4zG/gJQUCqFBtDHxe4ya7BFDVSbcuLdnZoDUAVlR++/Q72qe057TGpwHgB95M1rKLbJoFxdlVNFIhhBCRIAFUBByuBiooA+VxGTdJBqpaURQFe39jGq/g519QVZW7ut2lH5sTF8ffdjv4PfCHrI8nhBC1mQRQEWBeSNiaGAig3IcWkcd4ncZNUgNV7fS87lJ9u23GRtbtyKF7endOb3I6AKoCb5RnoVa+D+aMohBCiFpFAqgICCoiP0wNVKzbHEDJW3jVTf2uHSmqlwpAnNfJL1/NA+CeHvfo18yPi2WLww4Fu2DrD1UyTiGEEOEnAVQEBNVA1TsoAxU0hVdm3CR9oKodRVGIPuNMfd+9aCFFTg+d63fmnGbn6MenBP6OWfF2pIcohBAiQiSAioDghYQT8fvVQAbKj2LRpnkUFKLdJcZNMoVXLbW65Hx9u9fejXz7xx5Ay0Ipgbf0fo2LZb3DATsWQPafVTJOIYQQ4SUBVAT4DuoD5fIGGmaask/RtmgUd6lxk0zhVUtxp56KLyoagMYlufw4dwWqqtIuuR3ntzSCqynJkoUSQojaTAKoCPAXBgdQpe5A1slc/2SLBXMGSqbwqiWLw0Fc//76fvq6Zazfo/393tX9LiyK9i21JDaGP6IcsOYzcBaE/CwhhBA1lwRQERBUA5WYaBSQm9/As8WAV2qgaoKU8wfq2/0yN/Dp8n8AaJ3UmkGtBunnXk+uB54SWDs94mMUQggRXhJARcDBU3ghC8itUcYN9liwyF9NdRV/1lmoFisAHfJ3sWjpJgrKPADc1e0urIp2bkVMNMujo7RpPPM6h0IIIWo8+Vc6zPxOJ6or0CDTbkeJiTEWEjZP4ZkDKGmiWa1Zk5KIO6WPvt/jn3V8tWo3AM0Sm3H5SZfr515Proea+zfs+DXSwxRCCBFGEkCF2cHTd4qi6AsJB3Uht9iNm2T6rtpLGHievt0vcwMfLd2J368CcPvJt2OzaOvirYmOYklMNKyYVhXDFEIIESYSQIXZwQXkQMgMVEzgH1xA3sCrARLOPVffPjlnGzmZOSz8S1v/rnF8Y65qe5V+/vXkJNQ/50B+RsTHKYQQIjwkgAozcw+o8i7kTvehReSxijmAkgxUdWdv2JDorl0BsKl+Ttm3mQ+XGgHS7SffTlRgWnZjVBS/xkbD7+9UyViFEEJUPgmgwuzgAnJAn8ILykCZ/ypkCq9GSDgveBrvlz+zyMjVWlGkx6YzuP1g/fzr9ZLwr/4QzL2+hBBC1FgnHEApimJVFOUPRVFmV8aAahtzDZQlqeJ18IICKJnCqxESzjOm8XpnbcHu9fCRKQs1rMswYqxa082tUQ7mWt2w4euIj1MIIUTlq4wM1APA5kr4nFrJV3BA37YmVrwOXmxgGRBApvBqiKg2bXC0agVAtM9Dz6w/+WLlLr1Rav2Y+tzYaah+/evJSXhWTAVVrZLxCiGEqDwnFEApitIUGARIcUcF/OYaqMMVkZv/UZU2BjXGwdN4hU4v367Zqx+7pcstJNi1jOI/djvfluyAXSsiPk4hhBCV60QzUK8AowDpEliBoDYGgSm80hBF5EEBlF0CqJrCPI136r5NWPw+3l28Q29pkOhI5N9dh+nXvFkvCefyqREfpxBCiMp13AGUoigXA1mqqq46wnW3K4qyUlGUldnZ2cf7x9VY5iJyS/lbeKEyUOZO1ZKBqjGiu3bFlp4OQJK7lJNztvF3VjE/bt6vXzOkwxBSHfUAyLLZ+Hz3T1CYWSXjFUIIUTlOJAPVH7hUUZSdwHTgHEVRPj74IlVV31ZVtbeqqr3T0tJO4I+rmXyh+kCFaKQZ6/MZN0kNVI2hWCwknH++vn/W7jUAvLlgG2ogqxhrj+X2Hnfr17yTFE/x8jcjO1AhhBCV6rgDKFVVR6uq2lRV1ZbAdcDPqqreWGkjqyX8BYfWQJWGykD5PMZN8hZejZI06CJ9u3/mOuw+L3/8c4AVO/L041e3vZomjmQADlitfLj1c/CUHfJZQgghagbpAxVmofpAhcpAxfi8xk3SB6pGie7WDXvTpgDEe5z0ytoCaFmocnarnbt7j9D3/xtrI3/1BxEdpxBCiMpTKQGUqqq/qqp6cWV8Vm0TqhN5mUcLloLaGHhdxk1SA1WjKIpC4kVGFurs3X8A8Ouf2Wzaa/z9D2pzCW0CWahSi4V31r0tLQ2EEKKGkgxUGKmqGlxEflAGSjG/hecxtiWAqnkSLx6kb/fbv5noQEA81ZSFslqs3NdnpL4/3eZh3+aZkRukEEKISiMBVBj5S0ohUByuxMRgcTgAUxsDcwbK4zRulCm8Gie6XTui2rYFwO510y9zIwCz1+3ln1xj+ZZz2lxCF5sWSLstClNXvhz5wQohhDhhEkCFkd/8Bl5g+g4qaGNgLiiWDFSNlDjIyEJdka8FUH4Vpvzyt35cURTu72XUQn3jzycjY2HkBimEEKJSSAAVRkEF5KYAKtRaeLHuEuNGCaBqpETT23gnZWwgIfB3+uWqXfydVayf69fhSk5VtL9jn6Iw5bcJkR2oEEKIEyYBVBj5QrQwgPIpPC+KojXPtCk27G7JQNV0jmbNiO52MgCKz8ctnh2AloV6ad6fQdfed/Kd+vYc9z627FkWuYEKIYQ4YRJAhVGoAnIITOGZp+9sMeAx6mSkBqrmShpkvIx6QdY6fXvOhn2s2WUsLN2t282c7bPp+88velxvvCmEEKL6kwAqjEJ1Iff4/Hh8anD9kz0G3MYUj2Sgaq7ECy8Ai/ZtZVn3B9c2d+jnJs3ZYgRJisIDnW/DGtj/3bWfudu+i/h4hRBCHB8JoMLIH7IH1KEF5LHWaFADa+FZHWC1R26QolLZ0tKI69tX21FVhhWtx2pRAFi6PZdFf+Xo17bpfRvXm9p/vbj8WUrNmUghhBDVlgRQYeQ7YM5ABQKoUF3IrVHGTZJ9qvHqDb5G31bmfMe1PRrr+8/P3YLfH8hCWe3c3eVWUgKtLvZ7i7XmmkIIIao9CaDCyNyF/JAmmkEBlDHNg10CqJou4ZxzsNavD4B33z7uis0iyqZ9q23YU8istXuNa3vfyvAi42vhg40f8E/hP5EdsBBCiGMmAVQYBdVAJQYCqPIWBuYu5Ippyk4yUDWe4nBQ78orjAPfzeTfA1rpuxO/30yxK7D2YVQ8l3W+iZOd2lyeR/UxacWkSA5XCCHEcZAAKoz8IRYSLg2RgYpVjLexcMgbeLVBvauv1reLFy7k9g5xpCdoU7VZRS5e++kv/byl752MPlCMEigoX7hnIT9m/BjZAQshhDgmEkCFUXAfKK0GyhmiiWaMYjVukim8WsHRogWx/QLF5H4/3tmzGHNRR/38u4t3GM0149Pp0vFqriw2mqlOWDaBPGdeJIcshBDiGEgAFUahOpGHykDFKKa/BpnCqzWSBw/Wtw989RWXdkmnT8tkALx+lXGzNhptDfo/wIP5BaR7tam9PGceE5ZOkN5QQghRTUkAFUYhi8hDtTFQFeMmmcKrNRLOPRdrSgqgFZOXLF7MU5d2IdDVgMV/5zB34z5tp34bkjpfzVM5Rtbpx39+5H87/hfpYQshhDgKEkCFierz4S8q0vf1PlDuQPGwOQNlzjJEJURkfCL8Di4mP/D5F3RqnMiNfVvoxybM3kxp+dfE6SMZUObimkLj62bi8onsL9kfsTELIYQ4OhJAhYm/qAgCgZElPh7FqtU56W0MTG/hxfr9xo0OCaBqk4OLyd27dzNiYDtS4rTWFXsOlPFqeUF5WjvochUP5R2giUcLqorcRTy59EmZyhNCiGpGAqgwMU/fBS0kHKqI3O8zbpQMVK3iaNmSuNP6aTt+P3nvvU+9WAePXthBv+adRTvYnBn4ejnjYeJUeDonV38rb8meJXy65dNID10IIcRhSAAVJsELCSfq285QReQ+r3GjBFC1Tsq/h+nbB2bMwJuXxzW9mnJKK60+yudXGT1jvdahPL0DdL6c3k4XN5mm8l5a+RKbczdHfOxCCCFCkwAqTIJbGBgZqLIQGahYr7FNVHzYxyYiK67/aUR10loYqE4n+R9/gqIoTLyiK3arVlG+ZtcBPlmeod1wxigA7s87QEeX9rXh8Xt4eOHDlHhKDv0DhBBCRJwEUGHiD9GFHExtDMydyIMCKMlA1TaKolB/mJGFyv/kE/ylpZyUHs9dZ52kH3/+hz/ZX+iEBp2g46U4gBeycohFC7IyCjOYuHxipIcvhBAiBAmgwiRUDygI3cYgxuM0bowyrhW1R+L552Nv2hTQvjYOfPUVAHef1YbWqVrvryKXl/HfbdJuOHsMKBZaeL08npWtf86sbbP4btt3kR28EEKIQ0gAFSZBU3j1TFN47hBTeO4y40bJQNVKis1Gyr9u0fdzP/gA1eMh2m7l6Su66Mf/tz6Tn7fsh/SO0H0IAJeUlHKpL0q/5ullT5NRmBGxsQshhDiUBFBhEtRE80gZKHepcaNDaqBqq3pXXok1OdCJfG8mhXPmAHBam1Su6tlUv27sNxu13lBnjQarFjg9tutvWkTVB6DUW8rDCx7G7XMjhBCiakgAFSa+ggP6dlANlCtEGwNzACUZqFrLEhND8tAb9f3cae+gBnqAPTaoI8mxdkDrDfXKj39BUlM49Q4AYlWVF3IKsFu0azbnbeaV1a9E+AmEEEKUkwAqTIJqoExv4RW7tJYFQUu5uIxslQRQtVvKkCEoMTEAuP76i6K5c7XjcQ4eG9RJv+7dxTvYuLcABjwI0drXT8ec7TyUdpp+zUebPmLh7oURHL0QQohyEkCFiS/flIFKSda3S9xewA+KRz8W7TT6/UgAVbtZ69Uj5YYh+n72K6+ierSvhat6NqFva6M31JiZG/BFJ2tBVMCQDfM4q/EAff/xxY/LUi9CCFEFJIAKE19+vr5tSzYFUC4vKF4UResyHWWNwqoGlnKxRYPVHtFxisirf+utWBK0QNmdkcGBmTMBrd3BM1d0xWHVvi3X7jrAx8sy4NQ7IaGxdk3xfsYr6aTHpgOQ78rnscWPyVIvQggRYRJAhYk5gLKaAqhilze4gNxqvF0l2ae6wVqvXlBfqJwpb+B3aq0s2qTFc8/Z5t5QW9hTApzzmH4sedlbPNfrYSyK9u27fN9yvtz6ZWQGL4QQApAAKixUny9kDZTX58fp8Qe3MJAAqk5KuWko1tRUALz795P/ibHW3Z1ntaZNmtYbqsTt4/GZ61FPvg4adtUu8JbRZ+233Nz5Zv2eyasmk1mcGbkHEEKIOk4CqDDwFRZC4O0qS2Iiil2blitxhWhhYDFN2UkLgzrDEhtL6l136vu5b7+Nr0irhYuyWZl01ckoWgNyfvkzm1nr98P/PWN8wNpPuSe9Py0TWwJQ4ilh3NJxMpUnhBARIgFUGAQVkCfX07eL3YFFg5UKAijpQl6nJF9zTVB38rz339fP9W6ZwtC+LfT9p77bRF6DftD+Iv1Y1I/jmXDaeJTAUi+/7f2Nb/7+JkKjF0KIuk0CqDDwHTAVkNc7qICcg1oYKFbjRpnCq1MUh4O0++/T93Pf/wDPfuONulEXdKBxUjQAeSVuxn+3EQaOB4tNuyBjMd3z93JjJ6O31Au/vyBv5QkhRARIABUGhysgB4KbaJr/CqJkCq+uSRw0iKh27QBQy8rInjxZPxcfZeOZK7rq+9+s2csvuUnQ2yhAZ95Y7ut6B80SmgFQ5CliwrIJMpUnhBBhJgFUGFQUQIXKQMUEpl8AyUDVQYrVSoMn78rIAAAgAElEQVQxo/X9gm9nUbZmjb5/dod0LuveWN9/bMZ6ivuN1JtrkreNmDWf8tRpT+nXLNi9gNnbZ4d/8EIIUYdJABUG3mMIoGLNiQIJoOqkuL59SRg4UN/f98xEfYkXgCcu7qQv87K3wMkLC7PgjFHGB/z6HH0S23Bd++v0Q8+teI6cspzwD14IIeooCaDCoMIi8vJ18MxF5H5TBOWQAKquSn9kFIrDAYBz/XoKvp2ln6sfH8WTl3TW9z9clsHqhldBcivtgPMALHyRB3s9SJP4JgAUugt5ZtkzMpUnhBBhIgFUGBy2CzmgWFz6sRi/z7hRMlB1lqNpU1L+/S99P2vyS/iKS/T9y7o35qz2aQCoKoz6Ziuec540PmDF28QWZjLutHH6oR//+ZG5GXPDPnYhhKiLJIAKgyMXkRvr4EkAJcql3nYbtnRtiRZfdg65U9/Uz5Uv8xLn0N7a/DurmNf2doTm/bQL/B6Y/wR9G/XlqrZX6fdNXDaRPGde5B5CCCHqCAmgwuBIAVRQDZTXa9woAVSdZomLI/3hkfp+7n8/xLV9u77fpF4Moy7ooO+/sWA7O3uPMT5gy2zYuZiHej9Eg9gGgLZW3sTlE8M/eCGEqGMkgAoDr6kPlDVkHyjTFJ7P2JY2BiLx4ouJ6dlT2/F42PfU+KA6pqF9W9CrhfY15fWrPLTEhtp1sPEBc8eQYIsLmsqbu3Mu8zPmR2L4QghRZ0gAFQYVF5GHmMLzmAMo6URe1ymKQsMnnwCrNlVXunw5hbONlgQWi8Kkq7pit2rtL1Zl5PNd2m1g0xpukrkW1n/BgCYDuPyky/X7nl72NPlOI7AXQghxYiSAqmSqx4O/sFDbsViwJhpBkZ6BMr2FF+txGjfLFJ4Aotu3J2XoUH1//3OTtPUVA05KT+C201vr+0/8eoCy3ncZH/DjU+Au5eE+D5Meq9VU5TnzeHb5s+EfvBBC1BESQFUyX0GBvm1NSkKxGku1lC8mHNSJ3F1m3CyLCYuA1HvvxdZAq2Py5eaS/corQefvO6ctTZNjADhQ6mFiwfkQpwVLFO2Fpa+T6EjkyX7Gm3pzds7hx4wfI/MAQghRy0kAVckqKiCH0EXkMe5S4wLJQIkAa3wcDUYbHcrzP5tO2fr1+n6Mw8pTlxq9oT76I48d3R40PmDxK1C0jzOansFlbS7TD09YNkGm8oQQohJIAFXJKupCDsYUnjkDFWsOoCQDJUwSzv8/4k4/XdtRVfY9OQ7V9NbmuR0bcH7nBvr+XRs6oKZ30nY8JfDz0wCMOmUU6THGVJ6slSeEECdOAqhKVlEBOVSwFp4aWLLDkQAW+esQBkVRaDj2cZSoKACcmzaR9/HHQdc8eUlnYgO9obZklTGv6X3GyT8+hsx12lTeacZU3vyM+fxvx//C/wBCCFGLyb/YlSxoCq9ecABVFKKIXF/KRVoYiBAczZuTepdRIJ796n9w796j7zeuF8MD57bV90f9kYqn9XmBPRXmPQ6qyhlNzzikwea+kn1hH78QQtRWEkBVMt+B0Mu4qKoaegqvfCpF6p9EBer/+19EtdWCJLWsjH3jnwqagrulf0uap8QCUFDm4e3of4ESeHlhxwL4ax4Ao/qMoml8UwCKPEU8vuRx/KofIYQQx04CqEoWnIEyAiinx4+WbPKhWAKZKBSiJIASR6A4HDQc/xQoWu+nkoWLKJozRz8fZbMy+kKjQ/nLaywUdL7B+IB5Y8HnJdYeyzMDnkFB+5zlmcv5bMtnkXkIIYSoZSSAqmQVFZGHbKJpcQT+KUMKyMVhxfboQfL11+v7+56ZGNQy44IuDTmlVQqgdSgfV3ipVlcHkPMnrP4AgJ4NevKvLsaixS+vepntBcZyMUIIIY6OBFCVrKIi8pAF5Ba7caNkoMQRpI14MKg31P7nn9fPKYrC2EGdypNUzNzqJqPTncbNv0wEpxZw3dP9HtoltwPA5XPx2KLH8PiNwF4IIcSRSQBVycxTeLZQGShzAbnFZtwoy7iII7DGx9Nw7OP6fsHXMyheskTf79o0iSt7NNX3793RFzUpsF+aC4smA+CwOpg4YCL2QAC/IXcD76x/JwJPIIQQtYcEUJWsokaaegbKaizdkqCYAyjJQIkjSzjvPBL+7//0/X1jn8BXXKLvj7qgPTF2rYB8/X4Xy1ub2hosexPyMwBon9Kee3vcq596a+1bbMzZGObRCyFE7SEBVCWrMIByl0/hGQFUvGIs8yJtDMTRavjEWKxJSQB49u4le/JL+rkGidHcfoaxTt6IjW3wN+qp7fhcMHeMfu7mTjfTM10751N9jF48GqfXtDajEEKICkkAVYn8Lhf+0kBncasVS4KRVSpyHpqBilcV42bJQImjZEtNpcHjj+n7+Z9+RsmKFfr+bWe0JjXeAcDeQjffNjJlobbMhq1aWwOrxcrTA54mxqatqbejYAevrn41Ak8ghBA1nwRQlch3wFxAnoyiGAGSsZCwsXhwgnk1DQmgxDFIvPhi4s86S9/PfHws/jLtays+yhbUXPOJ1XG4uhhv8DFnFHi0QL5ZQjNG9Rmln/p488es2r8qvIMXQohaQAKoShRcQF7BMi7mGii/KYJySAAljp6iKDR8apye5fT88w9ZL7+sn7/ulOa0So0DtOznFOtQiNam/cjfAUuMTNNVba/ijKZn6PvjfhuHy+eKwFMIIUTNJQFUJaqoiSYYb+EF1UD5fMYFkoESx8jeoAENHn1E38//8CNKli7VzlktjDq/vX5u6spC8vqONm5ePBnydgCBFgh9xxJn1wKunYU7mbp2agSeQAghai4JoCpRRQXkYO4DZcpA+Uy9dySAEsch6coriTvjdH1/76Oj9QabF3RpSI/mWibU7fMzIbMPNOqmXeh1wg+PQqATfsO4hozoNUL/nPc3vM+WvC0RegohhKh5JICqRBV1IQfTW3jmInKv0RNKAihxPBRFodHTT+sLV3v372ffU+P1c6Mv7KhfO3Ptfv7q/ZRx89YfYP1X+u7V7a6mV4NegPZW3hNLnsDr90bgKYQQouaRAKoSBReRB9dAFetF5KYAymN6ZVwCKHGc7OnpNJwwXt8v/P57Cr6bDcAprVIY2KmBfu7RFVGovYylXPj+ISjcC4BFsTCu3ziirFEAbM7bzIebPozAEwghRM0jAVQlMi/jYqtoCs9cRO4uNS6QAEqcgMSBA0m66kp9f9/48Xj2aoHRmIs6Yrdqb4SuyshnTqN7oF5z7UJnAXx7jz6V1zKpJXd1u0v/nDfWvMHOgp2ReQghhKhBJICqRIergQpVRJ7gkgBKVJ4Go8dgb9YMAH9REXtHPYLq9dIqNY5bTmupX/fMj7twXfIGlC9lve1nWPmufv7mzjfTMUWb+nP5XIxbOg6/6o/UYwghRI0gAVQlOmwAFaqRpjfwqrhiBVt0+AcoajVrfByNJ00Ci/ZtXbpyJdmvau0K7j2nLSlxWnPNPQfKmJbREE4zlnJh3ljI3QaAzWJjfP/xWAOd8lftX8VXW79CCCGEQQKoSuQ9UHEbg/IicnMNVII/8Ft9VAKYmm4Kcbxie/Yg7X6j83jutHco+vlnkmLsjBjYTj/+xq/b2N97JKQFisw9pTDjdggE9R1SOvCvLkat1ORVk9lXsi8yDyGEEDWABFCVyFwDFbqNgXpQI83yACoxEsMTdUT9228/pLWBe9curuvTjPYNtKniUreP5+bvhCumgiWwqPWelfCD0Svqzm530jKxJQAlnhKeXvY0qmpuny+EEHWXBFCV6HCdyItdXlC8KIr2Np5dsRFV/m+R1D+JSqRYLDSeNAlb40YA+AsL2fPAcCxeD2Mv7qRfN/OPPSwobgLnmVobrHwX/vgEgChrFONOG6efWrB7AXN2zInIMwghRHUnAVQl8ZeVoTq17JLicKDExurnvD4/To8/uIA8sIArAFHxERunqBtsyck0feUVsNsBcG7axL7x4+l/Un0uPrmRft2YGesp6XkHdDbe4GP2g7B3DQC9GvTi2vbX6qeeW/Ecec68yDyEEEJUYxJAVZKDC8iDFhJ2B3pAmQvIA712AMlAibCIOflkGjxiLPVS8PUM8t57j3GXdqZerBZY7TlQxgvztsKlrxn1UD4XfD4USrVAaXjP4TSMawhAviuf51Y8F9kHEUKIakgCqEpy2C7keguDMv1YvMVuXCABlAiT5BuGkHTZpfp+1osv4fhtAU+YpvL+u3Qnq/Z54NqPjXq8gn+0IMrrIt4RzxN9n9Cvn7NjDr/u+jVCTyCEENWTBFCVJLiAPLj+KWQTTcUUQDlkCk+Eh6IoNJwwgZhe2hItqCp7Rz3CBfZ8zmyXVn6IR75eh6teK7jiLePmjMV6k83Tm57OJa0v0U9NWDqBQndhJB9FCCGqFQmgKklwAflRNNE0/6eXt/BEGFkcDpq+/hr25lr3cdXpZPfddzPhtFRiHVqvp7+zipk8fyt0uAjOfdK4ef2X8PMEAB455RHqR9cHIKssi5dWvhTZBxFCiGpEAqhKElQDVa+CAMpcA4Wp75NM4YkwsyUn02zqVCyJWrDuy87B89D9PNbfKCh/a8F2fvkzCwY8COb18ha9BCvfJykqicf6PqYfnvHXDH7b+1vEnkEIIaoTCaAqie/AkWugghYSNrfTkbfwRAREtW5F0//8B2xa3yf3tm30e3sCA1vE6deM+HwNmYVOuOhFaPt/xs3/ewi2zmNgi4EMbDFQPzx2yVgKXAURewYhhKguJICqJN4849Vua72De0Bpb+EF1UD5fMYFkoESERLX91QaT3pO73zv2riRRxZOo1mstp9f6uG+T//AiwWufh8addNuVH3w5S2wdw1jTh1DcpT2S0JWaRYTlk2QBptCiDpHAqhK4s3J0bdtqfWDzpWEqoHySwAlqkbSoEE0HDdO3/f8sZo3tn6JQ9W+Tldm5PPS/K1aZnTIl5DUPHBhCXw6mFRXKU+eZtRJzd05l9nbZ0fyEYQQospJAFVJvNnZ+rYtLS3oXKgi8nivx7hAishFhCVfO5j0hx/W920rlzEt41tsfu1r9c1ftzF34z5IaAA3fAnRSdqFxfvhk2s4N60XV7W9Sr//meXPsLtod0SfQQghqpIEUJUkKIBKTw86p9dAmafwPG7jAmljIKpA/WH/pv5dd+r76WuW8tKmL/Qgavj0NWzcWwDpHeC6T8Hq0C7M3gKf38ioHg/QPEHLTpV4ShizeAw+c2ZVCCFqMQmgKoGqqviyTVN4B2WgQjbS9BjBlEzhiaqSdv/9pPzLeOOu3d+refqPj7H7vJR5fNz635VkFTmh5QC47A3jxp2LiJ09gmf7P4NV0Voh/JH1B2+ufTPSjyCEEFVCAqhK4DtwANWjTclZ4uOxxMQEnQ9ZRO4qNS6QAEpUEUVRSB/1MPVvHaYf67ZrA+NWfojd5yGzwMltH67C6fHBydcE94jaOIOTV0/nzm5GFuutdW+xcPfCSD6CEEJUCQmgKoE3q+L6JzBnoFz6sQR3iXGBBFCiCimKQtpDD1H/9tv1Yz0zNzF+2XtEe12s3XWAkV+uxe9XtR5RpxjXsfxNbisq49RGp+qHRi8aLfVQQohaTwKoSnC4AnKooIjcWWRcIDVQooopikLag8NJvfsu/Vj37L94dslbxLtLmb0uk+d+2KK1P7jgOeh0mX6d9cdxPF+/Hw1iGwBQ6C5kxK8jcPlch/w5QghRW0gAVQmOLoBSg4vIfYHCcls02BzhHqIQR6QoCmn330/a8Af0Yx3y/+H5xW+Q7Czk7YXbeXvhNrBY4Yq3ocUA/bqU2Q/zUqursVm0Jp2b8zbz7PJnI/4MQggRKRJAVYLDvYEHgSk8xY2i+AGIsjjQlxKW6TtRzaTeeScNnhir77cq3MdLC6fQoCSXid9vYcbq3WCPhus/hQZdtItUH93mPMGo1kZrg6//+prpW6ZHevhCCBEREkBVgiNloEpc3uACcnuscVKm70Q1lDJkCI1feB6s2ht2jUpzeWnRFJoX7mPUV+u0NfOik+DGryG5lXaTz8V1C95kUMN++uc8t+I5WS9PCFErSQBVCY5mCi+o/skabZyMTQnr2IQ4XkmXXELT119DiYoCoL6zkBcWvUHr3Azu+ngVv/2dAwkN4aZvIEFblFhxF/Pkmnl0TmwNgE/1MfLXkWw/sL3KnkMIIcLhuAMoRVGaKYryi6IomxRF2agoygNHvqt28mZl6dsHB1CqqlLi9gXXPyl244IYCaBE9ZVw9tk0m/Y2ljhtweFETynPLnmL9nv/5N///Z3ftuVAcksY+o3+tRxTls9r2zeSHqXtF3mKuOene8h35lf0xwghRI1zIhkoL/CQqqqdgL7APYqidKqcYdUswTVQwQGUy+vH51eDM1CBxoMAxAavmydEdRN3yik0/+ADfZHsWK+LCUvfoWfGWv79we8s3ZardSu/8WtwaDV9aUXZvL5nFzEW7QWJ3cW7Gf7LcHkzTwhRaxx3AKWqaqaqqqsD20XAZqBJZQ2splBV9bBF5HoLA1MGKl5VjAtkCk/UADFdu9Dik4+xNdBaFdj9Ph5b8SHn/bmIf38QyEQ16QlDZ+hrO3YsyuXZnHwUtK/31VmrGb1otCz3IoSoFSqlBkpRlJZAD2B5ZXxeTeIvLkZ1asGREhOjT3WUKwnRAypRVY0LJIASNURUmza0/PQTHC1aAGBB5Z51Mxm89jtufnc5X6/aDc1OgZu+hWgtW3VuQS4PFhhNY+dnzGfi8omo5u8BIYSogU44gFIUJR74GhiuqmphiPO3K4qyUlGUldmmTE1tcXABuaIoQeeLnCGaaJb3gAKpgRI1ir1JE1pM/4zobifrx67b+jP3//4Zj3y+isnz/kRt3ANuma1PT9+Sl8ONhcX69V9s/YKp66ZGfOxCCFGZTiiAUhTFjhY8faKq6oxQ16iq+raqqr1VVe2dFuINtZrucAXkYGSgzEXk8V6PcYFkoEQNY0tOpsUHHxB/1ln6sfN2rWLCb9N474d13D99Dc76neCW7yG+IQrwcG4eFxYbmag31rzBF39+EfnBCyFEJTmRt/AU4F1gs6qqkytvSDXLEXtAucszUGX6sQSPEUxJEbmoiSwxMTR9/TXqXXONfqx7zjYmL3yNlb+t45LXFrPB0whu+wkadMECPJOdS78y4/vg6WVPM/OvmVUweiGEOHEnkoHqDwwFzlEUZU3gfxdV0rhqjCMtJFzs0gpmgxppukqNC2QKT9RQis1Gw/FPkTZ8uH6sWXE2Ly/4D47N67l8yhJeX1WG9+bv4aSB2IGX9+fQ2aW9iaei8uRvT0oQJYSokU7kLbzFqqoqqqqerKpq98D/vq/MwdUEh2thAKGLyONdRj2ITOGJmkxRFFLvvIMmL09GcWgtC5LcpTy7ZCpn71jOi/O2cs0HG9h89tvQ5zbiVJW39mXT0eUGJIgSQtRc0on8BB3NMi5AcCNNp6nWXjJQohZIvPBCWnz4X6z1tSlpu9/HiD++4K61M1i3M5eLpyxjnO9flF7wCkkWB9P2ZR0SRH259cuqfAQhhDgmEkCdoKNZxgUqeAvPHqctyipELRDTvTstP/+cqLZt9WOX7viNZ5dMJaG0kA9+28np85syt98nJNZrdUgQNX7peP6z+j/S4kAIUSNIAHWCjvYtvKBGmn6/tiEF5KKWcTRtQsvpn5FwwQX6sa65O3jt11dol/8PuSVu7pjv4nplEmrLi4OCKIBp66fx6KJHcfvcoT5eCCGqDQmgTtCRMlD5pVrLgqBGmv7Ab9ixyeEdnBBVwBIXR5OXJ5M+8iGwaD9iUp0FvLjoDQZmrABg2R43PTZfyy+NhvNeVj4DSo23877f8T23zR0ma+cJIao1CaBOgL+0FH+J1ttGsdv1tcLM8krcgB8sxhpgceUZKKl/ErWUoijUv/VWmr39NpakJADsfi8j/viC+9bNxOb3oqoKw7f15jbfeJ4rimZwYZF+/+rsNVz9zWWsyFxRVY8ghBCHJQHUCThSF3IIBFAWN4qiZZ1iLHZs5SdlCk/UcvED+tPqyy+IatdOP3bR9iW8ufo9kgMvUywta8aAvCe5sKwTI/KMrFOWK59b5w3j1VUv4/F7DvlsIYSoShJAnYAjTd8B5Je6g6bvEhS7cVJaGIg6wNG8uVYXdaFRF9V091Y+WvYa55TtAqCIWK7Ou5uMA9fzalYByT6tf5oKvLPhPW6aNZjNuZurYvhCCBGSBFAnIKiAPEQPKNAyUEFNNBWbcVIyUKKOsMTG0mTyZNIfHqnXRVkP5PPw/NeYVLoSRfUDCh+4zmJ83hO8kh0X1LV8Q8HfXDt7MGMXP0ZWaVYFf4oQQkSOBFAn4EgZKLfXT5HTG9zCANM0n9RAiTpEURTqDxtG8/fexZqaqh30+zl53nRm7f6aLvHaNPdOtRGD8x+nT9ZZjMgrwBZoa6AC32ybxcUzLmLKminklOVU0ZMIIYQEUCfkSAHUgdLAq9ihWhiATOGJOimub19azfia2D599GO2VcuZPP9FhjfSsk5ebDxTegVfZj/K1LwYzioxlj8q87mYunYqA788j5ELRrIic4X0jhJCRJwEUCcgeBmX9EPO5wUCqKAaqEBtByABlKiz7OnpNH//PerfcYd+zLd/P+dPe4rp9baTEqvVCm7yt2BI1lh6FF/CW/vzaWfqGeVVfczdOZdh84Zx4YwLmbRiEsszl0vBuRAiIiSAOgFHykDlFQcCKKtRyxHvNf1wlyk8UYcpNhvpDw6n2VtTsQZaHeD1kvTBG3yx5xsGNtW69PuwMj5vIE8WTWCypy2TsnLo6XQGfdae4j18vPljbp13K2dOP5NRC0fxw44fKHIXHfzHCiFEpZAA6gR4jtCFPGQGymP6wS8ZKCGIP/NMWs34muhuJ+vHPAt+YdSXE3jxJA8Oq/Zj6i9POmfuuou/48fwXmkMM3Zncl1hUfC0OFDkKWLOjjk8vPBhzph+BrfNu425O+fiV4OvE0KIEyEB1AnwZhtFrCG7kJcEphvMAZTbqOWQt/CE0NibNKHlRx+RfNNQ/Zh3/346vzSGbx1r6JhqrBk5OaM1Z5Q8h73DPTxWUMbCjN28lZnF9QVFNPIGB0le1cuyzGWMXDCSK769gv9t/x8+vw8hhDhREkAdJ7/Lhb+gQNuxWrGmHJpNyisJLONiLiIvn8KzRoE9NuzjFKKmUBwOGo4ZQ9M3pmBNDixzpKrw2Ye8vuQNHmhlvMG6p1jlrN9P4ZUOn0DbizjN6WRMXj5zd+3myz2Z3O2OolN8i6DP316wnUcXPcpl317GssxlkXw0IUQtJAHUcQrKPqWmolgO/U+ZV6It3xLUxsC8kHCIzuVC1HUJ55xDq2+/Ia5/f/2Ye/MmLnj9Ub6M2kCDGON77ZWVLk7d/m/mdp+CP7k1CtDB7eGuPX/x+fpFzI/rxW3thxBnj9PvySjM4PZ5tzN17VSZ1hNCHDcJoI6TN/vw9U8AeaWHZqAS9IWEpf5JiIrY09NpNu1tGowZjeJwaAc9HuI//4CPfn+T6xON4vC8Ejd3LEvm3LLnWN/+flRbjH6u4YaZ3P/LG8xtPpg7u95Ggj0BABWVKWumcPdPd3PAeSCizyaEqB0kgDpOR7WMS0mIInJ9IeHk8A1OiFpAsVhIuekmWn0zk5gePfTjvr//4qaPJ/BJ2WJOMs2C7zjg5ZK1fRnkn8yWlHOME65Ckn58inuWfcas3o/Ru0Fv/dSSPUu4ZvY1bM3fGolHEkLUIhJAHSdv1pEDqLwQReRBU3hCiCOKat2aFh9/RIMxY1BiAtklv5+Uud/wxvxJvJKeTXKMsUTSptIkLth7K0Pdo8m0NTM+KGsTqZ8OYVqRwrB21+qH95Xs47Z5t7H9wPZIPZIQohaQAOo4HU0GqjyACprCK6+5kCk8IY6aYrWSctNQWs/6Nqg2ypedTfu3J/H1js95skcCTeoZ03eL/F05o/gZJnqupxTjLT7bxq8Z/sub/KfR/xFvjwcgz5nHrfNuJaMwI3IPJYSo0SSAOk6ezL36tq3BoV3IVVU19YEyNdLUp/AkgBLiWDmaNaPZO9No8vLkoF9cXMuW0u+Z+5gZt4lp13XljHbaOQ823vZdwtnOF5nl62d8kLuYs397hzeLFWKsUQBkl2UzbO4wdhftjugzCSFqJgmgjpPnn136tqN580POl7p9uL1+wIdiDQRSQJxeRC5TeEIcD0VRSLzwQlrP+Z7koUMh8Aas6naTO2UKrR+5nTfae/hl5FncOqAVidE29pPC/Z77uN79GFv9TfTP6r53I1P27CVasQKwv3Q/t867lazSrJB/thBClJMA6ji5dxu/pTqaNTvkvD59ZzPeFkpRbFjLd2QKT4gTYo2Pp+FjY2j55RdEd+2qH3dnZLBr2K04Jj7BI6eksnzMeUy6qist6sey1N+Zi9zP8qznelyqtt5en7IS/rN3L47A7zZ7ivdw/8/34/Q6Q/2xQggBSAB1XPwlJfhyAn2g7HZsDRseck2oACpNNf3nlgyUEJUipnNnWk7/jAZPjMWSkKAfL/z+e7ZfNIiyL6YzuGcTfhxxJs9c0YX6iXG85buEi9wTWe0/CYB+Thcv78/CqmpR1MbcjTyx5AnUwL4QQhxMAqjjEJR9atwYxWo95Jry+ieLrVA/luozNe2TGighKo1itZIyZAhtvv8fiRdfrB/3Fxez/+mn2Xn9ENQ9u7nh1BYsePhsRgxsx06lKVe7x/GMZwgu1cYZZU4eyc3X752zcw7T1k+riscRQtQAEkAdB/c//+jb9hD1T2DqAWXOQJUv4wIQK32ghKhstrQ0mrz4As3ffw9Hy5b6cee6dey48ioK58wh2m7l/nPb8vntfWmQFMs038Vc6X6KDH861xcVc22h8T372h+v8VPGT1XwJEKI6k4CqOMQVEAeov4JQk/hpbqMt/FkCk+I8Inr149Ws74l9f77wCoFzHgAAB9+SURBVK7VOvmLi9nz4Agyx43D73TSu2UK399/Oud2SGej2opL3M/wg68Pj+Tmc0qZUf80etEj0mhTCHEICaCOg3u3EUDZmx99AJXmDvxQttggKjF8AxRCYHE4SLv7blp++il20y86B6Z/zs7rrsezdy/JcQ7eubk3/+7fikLiuNMznEmeG3ghK5dmHi1jXOZzMeLHeyl2F1fVowghqiEJoI7D0WSg8kPUQKX5fNpGTIosJCxEhMR07UKrGV+TcOEF+jHXli3sGHwtZevWoSgKYy/uyM39WgAK7/gGMdZ5Dy/vzycm0LctozSTsT/eK0XlQgidBFDHwb3LlIE6lim88gBKWhgIEVHWhASaTJ5Mw3FP6lN6vpwcMobeROGcOSiKwrhLO3PDqVpN4//8fZlQ8iBjc42s04/Zq/hw+fNVMn4hRPUjAdQxUr1ePHuNLuTHUgMVlIESQkSUoigkX3cdzd99B2tSEgCqy8WeB0eQ8+abAEy4rAvX9dG+pxf7u/Ju7giuK3bpn/Hylo9Y+ff3kR+8EKLakQDqGHn27QOvF9De+LHExIS8Tgug/Cg24zfYNK9koISoanGnnELLz6cHvaWX/ep/2PfUUyiqn6cv78KAk1IBWKOexB9ZD9DNpdVD+RSFkYseITtHisqFqOskgDpGHnMLgwqyTwD5pR4UawmKotVQJFmjcZSflABKiCrlaNmSlp9PJ7ZvX/3Ygemfs2f4g1i8Hl67voe+MPFKV0vqFd5EciCDnGuBkd9dh8dZUCVjF0JUDxJAHSP3URSQ+/wq+aXu4Ok7i7EavEzhCVH1rElJNH/7raDGm0Xz57Pr1ttI9Dl5a2gvomzaj8jZOd04y3MhlkAR+WqLh1e/vBz8/pCfLYSo/SSAOkbuXeYmmqEDqIIyD6p6UAG5YjMukB5QQlQLisNB4+cnkXLzzfqx0t9/J2PoTbS3uXj2SmONvQ93nMPl9u76/n/9Ocybc29ExyuEqD4kgDpGnl2mZVwq6EJuFJCbWhiYf1GVKTwhqg3FYiH90UdIf3ikfsz1559kDBnCoGRPoL2BZvrm6znNlqbvj81awI41/43oeIUQ1YMEUMfI3MLgyD2gzC0MTBGUZKCEqFYURaH+sGE0eu5ZCKxt6dmzh4whNzCiuZcODbVFil1e2JUzkqaqllEutVh4cOUkSvetq7KxCyGqhgRQx0BV1aMqIs8tDtHCwGO8Ci01UEJUT/Uuv5xmb0xBidZqFn35+WQOG8bLrZ04AvVQmzJVeiWMJirQU3Ob3cq42UNRy6SoXIi6RAKoY+DLz8dfUgKAJTYWa0roQKg8AxU0hecqNS6QKTwhqq34M8+kxQfvG72iSkthzEO8mJypX/Px73Hc1PhGfX+O3c9nM64F6VQuRJ0hAdQx8Jg7kDdvjlLBcizlNVBBU3ilRjAlU3hCVG8x3bvT4tNPsDVqpB3wemk77QVGFqzSr/l0ZW8uq2cUlb/g2c2anx6P9FCFEFVEAqhjcDQtDADyQ3Uhdwa27bEQkxyeAQohKk1Umza0/OxTotqepB8795fPuOfPOSiqn32FTrIL76ajTVsY3KsoPJQxk7ytc6pqyEKICJIA6hgcTQsDKM9AqaGXcanXXBYSFqKGsDdsSIuPPyamVy/92MWbf2LkqunYfR7mbsxjYPMXSVS17+ksm5WRCx7Cc2BXRR8phKglJIA6Bp6jzEDllbrBUoZi0ZZ8ibU4iC2vjajXosL7hBDVjzUpiebvvkP8uefqx87ZvZpJi6eS7Czk5fkFjOg6Rj/3u8PKxJlXo3rdVTFcIUSESAB1DMwtDA67jEuJO6j+Kc1q6kKeLAGUEDWNJTqapq++Qr3Bg/VjHfMzeHXBqzTK+ocPlzXjnuZGR/OvLKV8OuumqhiqECJCJIA6BuYi8oqaaALklriD3sBLVU3/mSUDJUSNpNhsNHxqHA1GPwoW7Xs6rayAFxe9TsKyBRS6buKi+Nb69c8XbmDxb89X1XCFEGEmAdRR8judeLOytB2rFXv52zkh5Je4Q9c/gWSghKjBFEUh5eabafbWW1gStOaa0T4Pj/3+EaVvvM7A9q9wsqItQuxXFB7+879s3/FzVQ5ZCBEmEkAdpaAWBo0bo9hsIa9zenyUuH3BLQzMPaDqVZy5EkLUDPGnD6Dl59OxtzB+Ibp268/k3DeCx3u+TsPAwgPFFgt3/jqcffnbq2ikQohwkQDqKB3NEi4AB0o9wEFNNEtNHYplCk+IWiGqdWtaffE59tP668e6ZW4hb9hIXml0LzF+LYrKtKjc+d21FDgPVNVQhRBhIAHUUQpuollxAJVboi3ZEryMi1PbiE6CmHrhGaAQIuKsSUm0mfYWzmuNgvGUgmz8o95kSn4/bIG3b7epTu6deQVl3rKqGqoQopJJAHWUXH//rW87mlecRcovKc9AmabwvOU9oCT7JERto1it9HhqNOtvH02pLQoAm9tF/NtLeGNJfSx+LYha485h5Kzr8fg9VTlcIUQlkQDqKJWt36BvR3fqVOF15RmooDYGvkBBhBSQC1FrXT18KJ/e/CS741L1Y/UWZfH251biS7UgamHRNsbMuRWv31tVwxRCVBIJoI6Cv6wM119/aTuKQnSXzhVeuztfS9EH1UD5JAMlRG1nsSg8dvcgJl36CMsbdNSPJ+50M+V9Py32a0HUDzmreezHe/H5fRV9lBCiBpAA6ig4t2yBQBDkaNUKa3x8hdduzy4BxYVi1boQO1BI9JdnoFqGe6hCiCqUEudgyh1n8tKZt/FJ+4H68ZhClWc/9NF/o/az4PvMJYz9ebgEUULUYBJAHQWnafoupmuXw167Pac4uIAcK/rKd9LCQIhar33DBF67oRefdjqfp069xaiL8sIDs/wM/cmHxa/y3Z5fefKXERJECVFDSQB1FMo2rNe3o7t0rfA6VVXZnl2CxdyF3GuqdZApPCHqhLPap/PkJZ1Z1qgLD5z5ALvi0/Rzl6xQeWy6n4RSlW93/8yYnx+QwnIhaiAJoI6COQN1uPqnvBI3BWWe4AyUy/TasmSghKgzbj6tJTf3a8HuhHSGn/kAvzU0fnZ0zVB57n0frfapfL9nAQ/Nuwu3TxYfFqImkQDqCHxFRbh37NB2bDaiO3as8NodOSXAQS0MfIEMVFw6OGLDNk4hRPUz9uJODDq5EaX2aJ4+9WY+7HA+qqJN6qcVwoSPfJy+3s8v+5dz75ybKfWUHuEThRDVhQRQR+DcuEnfjmrbFkt0dIXXbs8+NIBKK+8BJS0MhKhzbFYLr1zbnf/r1ABVsfBZh4GMO/VfeKO1X6YcXrhvtp9b5vtYkbWeO2dfT4Gr4AifKoSoDiSAOgKnqf4ppsvhC8i35RQDBNVASQsDIeo2u9XCa0N6cHZ7rQ5qRcNO3DngPgobGCsaXLRSZexnPrZnbuPmb64gszizqoYrhDhKEkAdQVADzSMEUKEyUKk+yUAJUddF2ay8eWMvBpykNdncE5/GLb3vYHvHPvo1nXbBs+/7YHsWN35zGX/m/VlVwxVCHAUJoI7Aud6UgTpCCwO9BspupOCNDJQUkAtRl0XbrUy7qTfndWwAQJk9mnvaDebnAVdBoC4qtQjGf+yj68oSbpk1mGX/LKjKIQshDkMCqMPw5uXh2bsXACUqiqi2bSu+1ucnI7cEFDcWR452jwrNPYEicpnCE6LOi3FYmXpjT244NfALlaLwQmo/3rzgXgg06LX74I4f/Az71sOD39/Dx6unoAYWJRZCVB8SQB2Gc4Np+q5DBxS7vcJrd+eX4fGpWKL2oSjaD7uWPpXY8h98MoUnhEArLH/68i48fH57/disqBbcfcYDuJq11I/136wy8QMfX857k9E/3EqZtyzEpwkhqooEUIdRZpq+i+5acQNN0DqQA1hj9ujHOjkDryQrFkhqFuo2IUQdpCgK95x9EpMHdyPKpv0Y3uFIZnD3O9ja51z9uoYH4OkPfdi+XcYtn1/A7sJdVTVkIcRBJIA6jKNtoAlGAbkl2gigOroCjfESm4C14uyVEKJuurJnU2be3Z9WqXEAuK12HmhyIe+dMww1OrAEjB9u+NXP0GlZDH/rImZs+kSm9ISoBiSAqoCqqpRtMK+Bd6QMlBZAWU0BVCd3IICS+ichRAU6NU7ku/sGcEm3xvqxLxM7Muz0B8lvbLx80mYfPPm+l3UvT+SBWTeQU5ZTFcMVQgRIAFUB7759+HK0H1CWuDgcrVod9vrt2cWgeLBE7dePdSjPQEn9kxDiMOKjbPznuu48c0UX4hxWADLjUrmx9z181X0QqlV7S8/mh2sX+bls0h88/tx5fLN1Bn7VX5VDF6LOkgCqAubsU3TnziiWw/+n2p5dgiVqP4qi/TBrbo0joTzNLi0MhBBHoCgKN5zagvkjztRbHfgtVt5teTZ3nDWS3LT6+rWN8+CBz12UDn+c4dMuZUPOhoo+VggRJhJAVaB02XJ9O/oI/Z+KnB6yilzB03c4jAtkCk8IcZQa14th2k29mHpjT9ITtDqoXQkNuOm0R5je9Vx8ph8tPbar3PbKNn6+dzDPfvsg+0v2V/CpQojKJgFUCKrXS+EPP+j78aefftjryxtoBhWQF+YaF6RW3D9KCCEOpigKF3RpxM8jz+KBc9sS67DiVyz8t82FDD33CXa0SkdFy3Db/DBwjcqgMT8w/Y5zeX3+BA44D1TxEwhR+0kAFULp77/jy9UCIGtaKrF9+hz2+h16Afle/VjHwmxtw5EAjbqHZ6BCiFotPsrGgwPbseDhs7mpXwtsFoX8qETu7jaKV86+Fle6ol9r98H/rfQx4MFPee+uM3hn0UuUeEqqcPRC1G4SQIVQ+P33+nbiBReiWK2HvX5bdgngxRJlLADaye3RNloOAKstHMMUQtQRaQlRjL+sCz89dCbX9GqK1aIwL+kUrur3LL8O6IE71adfG+WFC5d66HnPO0y9+3Q+Wf4WLp+rCkcvRO0kAdRBVLebwnnz9f3Eiy484j3bs4uxRGWhWLQfYk0UB0n+wJsxrc8MyziFEHVPi/pxvHBNN34OBFJY7UxKvYHb+z/O3gGpuOt79Wtj3HDRojLa3/4Kr9/Tn5mrP8br9x7m04UQx0ICqIMU//Yb/gJtMeD/b+/Og+Qu6zyOv799zz2ZM5lkzBCSEJYQyQFJJEIEwRgEtowLsdYoioAuLGspKJS1rLBY4GJJibWwiAuFsoiUoiYChjPhEEwiAQLkMORgjiRzZnruo/vZP7pnMgOTzNUzPcfnVdU1/Xv6+XV/f/NUZ755nuf3PP6iIlLO6H/4bV9VU+/5Ty09us1PUgIlIonVlUg9/+1z+cLiGVR787gy7yZu+eS1NCxPpW3KsR6ptDZYvamJ4q/+kHuvPZtn3tbSByKJoATqQ3oN363+LGZ2gtqxBTf3Vzf1vgOvOZ5ApRVAwakjEqeISEleGj/ukUi945nLZYW3cvfKL9O+zEtrVu9E6oIXw+Su+z73/8sKXt75tFY0FxkGJVA9RFtbaXzu+e7jzNWr+z3ncLiVlo5I7wnkXSuQzzoX+knARESGqyuR2vitc/js/Glsdgu5dOqd3HPeOhqWBmnOPtbjlNoGK1+sI3Xtt/nfa8/hb3/fnMTIRcYvJVA9NG5+iWhzbAPgQEkJwVP77z3atLsKiOAJHZtA3r0H3qyViQ9SROQ4Zhekc9+XFvOHa89m+aw8XnSLuGza7dy18kqqlqXR9KFE6uwXqmHNN/jVNSvYsXNT8gIXGYeUQPUQfvrp7ueZq1f3O3wH8Pvt5XiCVZgndtddYWeE3K4J5Jr/JCJJcEZxNo9etZRffu0sTivK4nVO48tTb+X2ld+gbHkmDT0TqXZYsrmG6Be+yaPrzuTlVx/RHCmRAVACFRdpbKJx06bu44HcfVdW18yW/bW9J5C3xW8XzjkZsosTHaaIyICYGefMzWfDdSu454sLmZmbypvM5arCW7hl5fXs/kQuR6ccmwMViMDCrY3kXPlDnrj0DP7w8Peoaq5K4hWIjG1aoCgu/Kc/4VpbAQiecgrB2bP7PWf9W7F5T70mkPec/yQikmQej3HJx4v47PypPLa1lJ8+93d2NZbwrYKbmZpfw9W1/8fsPQfJPxLrcfcAp+3pgDvW89b963l/RREla69h+fxVZAYyk3sxImOIEiigs6aGyrvv7j7Ouvhz/Z7jnOP3b5SDteHPfLO7fL7mP4nIGOT3eli3bCZrFk3nwVf2c//mfRxuy+W23OtJXdbClfWPs/D9HUwrPXbO9FqYvr6Czj/9B+tn/YAPlhWTv+pSzj5pJfNy5uExDWLI5GWjeRvrkiVL3LZt20bt8waq/MbvEt6wAQD/jBnM2rAeT0rKCc95t6Kei+55BX/OS4QKY0sfTO/oZENZBX4MvrsPUnNGPHYRkaGob+7gN9s+4OG/HKT8aAsAHqJ8vuVZzit9gaK9nQTbPzoPtDkAb55s7Dw1jbRzz+WsOZ9iedFyckL6904mHjP7m3NuSZ+vTfYEqvHVVym98uvdx8UPPED6J1f0e94Pn3yPB17ZQ9rs/8LjawDg36truayhEaZ9HK55acRiFhFJlEjU8dzOI/zytQP85f0auv4k/EPnfr5y+AmKS8uZcqTvnqZOD+wqNnbMNMKnf4zpS85lafEnWFy4mDR/2uhdhMgIOVECNamH8KItLRz+wa3dx5kXXTSg5CkSdax/qwJ/9rbu5KnAGf/Y0BiroLvvRGSc8HqMz5w2lc+cNpXKhlY2vnOYJ3ccYst++N6M7+Cf0cnnmzezuvxlskvDBMLHkilfFOYfdMw/6OClAzQHDrCz+Jf8ucRD2xlzKVm0kqVFy1iQv4CQL5TEqxRJvEmdQFXfex8dpbEBf09mJoU33zSg817fV8ORcBNps48tQPfV2loCAN4ALPryCEQrIjKyCjJCrFtewrrlJdQ2tbNlfy1/3V/Dlv05PJ52PhmzG7m86QUuPLyV1EMNeGp6/wlJbYfF7zsWvx+B53cSTtnJzuL/YUORh5ZZRRSceTYLSpYyL2cexRnFeD0n3qhdZCybtAlU+NlnqXnooe7jghtvwJeXN6Bzf7+9HF/Wdjz+owDkRKKs6ep9WnkT5M1JeLwiIqMpJy3AqvlTWTV/KgCNbZ3sPhzmvYqlPHGogYPlFcz+YCPnHfkrxVWHaKn04W3qnRBltsBZexxn7YnAplKiDz5Ged5jPFVk7J/moXFGFqGZJZTkzWJu/hw+ljuP6VPmkBXKHtA6fCLJNOkSKBeJUHXPz6i5//7uspQli8les2ZA5z+94xB/fPMDgiWbusvW1YdJcS429+kT1yc6ZBGRpEsP+lg8M4fFM7smi59OJHoh+6ub2FleQ/3e18ne+RzFe98g7XAdLZV+vK295055gOJqKK52fOrtCFBLp6eW8tw3KM03Xss3KnKgNgs6M4xQ0EeuN0SeN5XCQAZTQ1PIC2UzJSWHnJQCctILSU2bimUUQnohBDTvSkbPpEqgOuvqqLjhRppefbW7zD99OkV33IF5+r8d94k3yrjht1vwF27AE6gBICMSZW24ATx+uPRe8PpHLH4RkbHE6zFmF6QzuyAdFs4ELgegpaWF0l1baXrtGXzvbMPKKohUt+Kv82Cud8+SLwozq2BmlQN639TUHIhQmd1GVVaYyuzDbMky6tKhPs2oT4P6VOgMOLJdlJxIlOwoZFmALE8K2YFMcoI55GZOozB7Jrk5JzMlZy5pU2Zh/uAo/YZkIhtWAmVmq4CfAl7gF865OxMSVYK17t5DeMN6jv7xj0SqqrvL01asYPqP78Kbnd3vezzy+kFu2fgkKSc93p08AXwp3EC6c3DuDTB1/ojELyIynqSkpDB34Tmw8Jxjhc7RUL6XQy/8mabtbxB5fx++ilqCjZ3HfZ/UdiiphJLKrsTqo3eNd3ognArhVA/1qUZjSoSmUCPhUCMVoUM0prxLUwiaQtAYMtoDDl/QEfD5yLAQGd50MoM5ZKcWkJ81g6l5JzM9/2RyUwuZEppCmj9Nw4nSpyEvY2BmXmAPcAFQBmwFvuice+9454z0MgbOOSK1tbQfPEj7/gO0HzhA4+bNtO3Z85G6ud/8BvnXXYd5+57EGIk63imv46ldO3jlg7cob9hGJPtNsGO/rwuamrmzsppA4Xy46kXwBUbs2kREJqJIQwNtf9/L0Xd3UffeLloPHsBVlBGsqcLX0TFin9vpgeYgtAShJQCtAWgJWPznsbKo1/B6DJ/Hi8/jJeALEPAHCfhT8AeC+AMh/IEgwUAqgWAqwWAqKYFUgoE0AqGUWFkojWAojVAojUAoHQukQCCE+UPg88f+Dnm8mNcDXm9sRMTrTVri5pyDaBSi0V7PMTsWn8czoJGb8W6kljE4C9jrnNsX/5DHgEuB4yZQI+no737HkTvuJNrYeMJ63txcpt12Kxnnn3/cOl959Fdsb/g1vkApHR5iv6Upx15Pj0a5uaaOixubsGlnwD89pORJRGQIvBkZpC5aSOqihRT1KHfOEamro6OsjI7yctrLymgrLaf5SCUdNTVEa2vhaB3e5qYhfa4vGpvkntnSs7SvDoWuskj8Z0sfdfrmgLb4YyiigPNA1GKPrufOIOqJ/4yXd42MmuvjcbzyPl73DLJPJdojlu54epXZR2J3xzknVse6y82BJ+rwRMGiRqs3yE+uPoWTcmNz3fxeP/d9+r4h/naHbzgJ1HSgx6L/lAFLhxfO0HnSM46bPFkwSMb555H5uYtJX3E2FjhxslPf2okLldLX/33ObGnl9uoaivJPh4tvhrmfiWXlIiKSMGaGLycHX04OKQsWHLdetL2dSG0tnTU1RGpriRytJxKuJxoOE6kPE6mvp6O+no6j9XTUHSUaPgoNDXi69i0dwzwA0dgcmbHK48ATOVGNwY5yHa++o93bQmXHO1QejpWEvMldW2w4Q3hfAFY5574eP14HLHXOXfehelcDV8cPTwF2Dz1c6UMeUN1vLRnv1M6Tg9p54lMbjy8znXP5fb0wnB6ocqC4x/GMeFkvzrmfAz8fxufICZjZtuONz8rEoXaeHNTOE5/aeOIYzgywrcAcMzvJzALAWmB9YsISERERGbuG3APlnOs0s+uAjcSGaB90zr2bsMhERERExqhhrQPlnHsKeCpBscjQaHh0clA7Tw5q54lPbTxBDHkSuYiIiMhkNfFXwRIRERFJMCVQ44SZrTKz3Wa218xuOkG9NWbmzEx3eYxD/bWzmV1hZlVm9mb88fVkxClDN5DvspldZmbvmdm7ZvboaMcowzeA7/LdPb7He8zsaDLilKHTEN44MNBtc8wsA3gSCADXOedGbt8cSbiBtLOZXQEs+fB6azI+DLCN5wCPA+c55+rMrMA5V5mUgGVIBrvVmZn9K7DQOfe10YtShks9UOND97Y5zrl2oGvbnA/7T+BHQOtoBicJM9B2lvFrIG18FfDfzrk6ACVP49Jgv8tfBH49KpFJwiiBGh/62jZnes8KZrYIKHbOPTmagUlC9dvOcWvM7G0z+62ZFffxuoxdA2njucBcM3vVzF43s1WjFp0kykC/y5jZTOAk4IVRiEsSSAnUBGBmHuAnwHeSHYuMuA1AiXNuAfAs8HCS45HE8wFzgJXEeiYeMLPspEYkI2kt8Fvn3Al3lJOxRwnU+NDftjkZwHxgk5kdAJYB6zWRfNzpd3sk51yNc65rc/dfAItHKTZJjIFsgVUGrHfOdTjn9hObSzNnlOKTxBjQVmdxa9Hw3bikBGp8OOG2Oc65eudcnnOuxDlXArwOXKJJ5ONOv9sjmdm0HoeXADtHMT4ZvoFsgfUHYr1PmFkesSG9faMZpAzbgLY6M7N5wBTgtVGOTxJACdQ44JzrBLq2zdkJPO6ce9fMbjOzS5IbnSTKANv5+vit7W8B1wNXJCdaGYoBtvFGoMbM3gNeBG50ztUkJ2IZikH8m70WeMzpdvhxScsYiIiIiAySeqBEREREBkkJlIiIiMggKYESERERGSQlUCIiIiKDpARKREREZJCUQInImGBm348v0fB2fIf6pcmOSUTkeHzJDkBExMyWA58DFjnn2uILSAaG8X6++Fo8IiIjQj1QIjIWTAOqu7apcc5VO+cqzOxMM/uLmb1lZlvMLMPMQmb2kJntMLPtZvYpADO7wszWm9kLwPPxshvNbGu8V+vWeFmamT0Zf893zOzyZF20iIxf6oESkbHgGeAWM9sDPAf8htj2Fr8BLnfObTWzTKAF+DfAOedOj2+F8YyZzY2/zyJggXOu1swuJLaH3FmAEdsf8hwgH6hwzl0EYGZZo3eZIjJRqAdKRJLOOddIbGPkq4EqYonTNcAh59zWeJ1wfFhuBfBIvGwXcJDYfnEAzzrnauPPL4w/tgNvAPOIJVQ7gAvM7Edm9knnXP0oXKKITDDqgRKRMcE5FwE2AZvMbAdw7RDepqnHcwPucM7d/+FKZrYIWA3cbmbPO+duG8Jnicgkph4oEUk6MzvFzOb0KDqD2Cas08zszHidDDPzAS8D/xwvmwt8DNjdx9tuBL5mZunxutPNrMDMioBm59wjwF3Ehv1ERAZFPVAiMhakAz8zs2ygE9hLbDjvoXh5CrH5T58G7gXui/dSdQJXxO/c6/WGzrlnzOxU4LX4a43Al4DZwF1mFgU6gG+OwvWJyARjzrlkxyAiIiIyrmgIT0RERGSQlECJiIiIDJISKBEREZFBUgIlIiIiMkhKoEREREQGSQmUiIiIyCApgRIREREZJCVQIiIiIoP0/3BpZzZb3fb/AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -256,12 +256,12 @@ }, { "cell_type": "code", - "execution_count": 308, + "execution_count": 356, "metadata": {}, "outputs": [], "source": [ "import eif_new as iso_new\n", - "F3 = iso_new.iForest(X, ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0)\n", + "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X)\n", "#S3 = F3.compute_paths(X)" ] }, @@ -274,13 +274,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "751 ms ± 1.23 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "1.99 s ± 126 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "698 ms ± 1.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "1.52 s ± 6.36 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] } ], "source": [ - "%timeit iso_new.iForest(X, ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0) #X.shape[1]-1)\n", + "%timeit iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X) #X.shape[1]-1)\n", "%timeit F3.compute_paths(X)\n", "# 749 ms ± 3.63 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) exlevel=0\n", "# 361 ms ± 4.18 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) without p *min-max\n", @@ -292,28 +292,26 @@ "# 1.99 s ± 126 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) get_paths0\n", "\n", "# 752 ms ± 10.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) exlevel=2\n", - "# 2.48 s ± 22.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) " + "# 2.48 s ± 22.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) \n", + "\n", + "#707 ms ± 5.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "#1.51 s ± 7.27 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] }, { "cell_type": "code", - "execution_count": 338, + "execution_count": 340, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 31 31.0 500\n", - "2 58 147.0 469\n", - "3 88 411.0 411\n", - "4 100 811.0 323\n", - "5 73 1176.0 223\n", - "6 58 1524.0 150\n", - "7 42 1818.0 92\n", - "8 0 2251.2732305771265 50 [ 1 4 2 6 1 5 1 2 1 2 5 2 1 4 20 2 1 1 0 1 1 10 3 1\n", - " 1 3 1 1 3 1 1 2 1 2 1 2 1 2 2 5 1 1 1 2 26 1 1 1\n", - " 1 1]\n" + "ename": "ValueError", + "evalue": "too many values to unpack (expected 5)", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mtrees\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnodes\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTrees\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m#n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpdotn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mleft\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mright\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrees\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"n\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"pdotn\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"left\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"right\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"size\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mxi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m#X.shape[0]):\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 5)" ] } ], @@ -324,7 +322,9 @@ "self = F3\n", "S = np.zeros(X.shape[0])\n", "trees = np.array([t.nodes for t in self.Trees])\n", - "n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\n", + "#n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\n", + "n, pdotn, left, right, sizes = trees[[\"n\", \"pdotn\", \"left\", \"right\", \"size\"]]\n", + "\n", "for xi in range(1): #X.shape[0]):\n", " ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", " tidx = np.arange(trees.shape[0])\n", @@ -342,25 +342,42 @@ }, { "cell_type": "code", - "execution_count": 311, + "execution_count": 359, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "array([364, 30, 157, 31, 409, 329, 472, 46, 142, 189, 145, 330, 485,\n", - " 479, 446, 143, 40, 447, 176, 453, 214, 16, 244, 457, 348, 184,\n", - " 61, 39, 336, 177, 237, 428, 94, 409, 30, 19, 167, 367, 475],\n", - " dtype=uint16)" - ] - }, - "execution_count": 311, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "1.68 s ± 5.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + ] } ], "source": [ - "ni" + "def score_samples_without_childidx(X, trees, limit=8):\n", + " S = np.zeros(X.shape[0])\n", + " n, pdotn, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"size\"]\n", + " #powers = np.power(2, np.arange(limit+1))\n", + " for xi in range(X.shape[0]):\n", + " e = 0\n", + " ni = np.zeros(len(trees), dtype='int')\n", + " w = X[xi].dot(n[:, 0].T) < pdotn[:, 0]\n", + " ni[w] += 1\n", + " ni[~w] += 2**(limit-e)\n", + " tidx = np.arange(trees.shape[0])\n", + " for e in range(1, limit):\n", + " w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", + " ni[w] += 1\n", + " ni[~w] += 2**(limit-e)\n", + " sel = sizes[tidx, ni]>1\n", + " S[xi] += e*(~sel).sum()\n", + " tidx, ni = tidx[sel], ni[sel]\n", + " # the size matters only at terminal nodes\n", + " size = sizes[tidx, ni]\n", + " S[xi] += limit*len(ni) + c_factor(size[size>1])#.sum()\n", + " return S * 1. / len(trees)\n", + "\n", + "%timeit score_samples_without_childidx(X, trees)" ] }, { @@ -544,225 +561,6 @@ "%prun score_samples_by_sample_pool(X, trees, 6)" ] }, - { - "cell_type": "code", - "execution_count": 237, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.48 s ± 7.87 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "1.56 s ± 4.88 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "1.5 s ± 5.04 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], - "source": [ - "from numba import jit, int32, float64, float32, uint16\n", - "\n", - "@jit(float32(uint16[:])) # 9.1 vs 13.5 µs\n", - "def c_factor(n):\n", - " return np.sum(2.0*(np.log(n-1)+0.5772156649) - (2.0*(n-1.)/(n*1.0)))\n", - "\n", - "#@jit(float64(float64[:], float32[:,:,:], float32[:,:], uint16, uint16, uint16, uint16))\n", - "def score_sample1(x, n, pdotn, left, right, sizes, limit, ni=0, S=0):\n", - " tidx = np.arange(trees.shape[0])\n", - " for e in range(limit):\n", - " w = x.dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", - " ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T)\n", - " if e: S += e*(ni==0).sum()\n", - " tidx, ni = tidx[ni>0], ni[ni>0]\n", - " # the size matters only at terminal nodes\n", - " size = sizes[tidx, ni]\n", - " S += e*len(ni) + c_factor(size[size>1])\n", - " return S\n", - "\n", - "def score_samples_by_sample1(X, trees, limit=8):\n", - " S = np.zeros(X.shape[0])\n", - " for xi in range(X.shape[0]):\n", - " S[xi] = score_sample1(X[xi], trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"], limit)\n", - " return S * 1. / len(trees)\n", - "\n", - "def score_sample(x, trees, limit, ni=0, S=0):\n", - " tidx = np.arange(trees.shape[0])\n", - " for e in range(limit):\n", - " w = x.dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni]\n", - " ni = np.where(w, trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", - " if e: S += e*(ni==0).sum()\n", - " tidx, ni = tidx[ni>0], ni[ni>0]\n", - " # the size matters only at terminal nodes\n", - " size = trees[\"size\"][tidx, ni]\n", - " S += e*len(ni) + c_factor(size[size>1])\n", - " return S\n", - "\n", - "def score_samples_by_sample(X, trees, limit=8):\n", - " S = np.zeros(X.shape[0])\n", - " for xi in range(X.shape[0]):\n", - " S[xi] = score_sample(X[xi], trees, limit)\n", - " return S * 1. / len(trees)\n", - "\n", - "def score_samples_by_sample_all(X, trees, limit=8):\n", - " S = np.zeros(X.shape[0])\n", - " for xi in range(X.shape[0]):\n", - " ni = 0\n", - " tidx = np.arange(trees.shape[0])\n", - " for e in range(limit):\n", - " w = X[xi].dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni]\n", - " ni = np.where(w, trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", - " if e: S[xi] += e*(ni==0).sum()\n", - " tidx, ni = tidx[ni>0], ni[ni>0]\n", - " # the size matters only at terminal nodes\n", - " size = trees[\"size\"][tidx, ni]\n", - " S[xi] += e*len(ni) + c_factor(size[size>1])\n", - " return S * 1. / len(trees)\n", - "\n", - "#%timeit score_samples_by_sample1(X, trees, F3.limit) #1.55 s ± 8.16 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "\n", - "S = score_samples_by_sample(X, trees, F3.limit) \n", - "%timeit score_samples_by_sample(X, trees, F3.limit) #1.64 s ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 1.87 s ± 1.82 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) fully functional\n", - "# 1.79 s ± 3.35 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "%timeit score_samples_by_sample_all(X, trees, F3.limit) #1.64 s ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 2 s ± 4.48 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "# 1.43 s ± 3.49 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) for f4 i4?\n", - "# 1.57 s ± 933 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) for f4 u2" - ] - }, - { - "cell_type": "code", - "execution_count": 261, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 2, 4, 8, 16, 32, 64, 128, 256])" - ] - }, - "execution_count": 261, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "limit = 8\n", - "e=0; 2**(limit-e)\n", - "np.power(2, np.arange(1, limit+1))" - ] - }, - { - "cell_type": "code", - "execution_count": 269, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.42 s ± 4.08 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - }, - { - "data": { - "text/plain": [ - "array([ 3.512636 , 8.05164026, 10.16188574, ..., 8.66337866,\n", - " 9.64911035, 11.90239893])" - ] - }, - "execution_count": 269, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def score_samples_by_sample_all2(X, trees, limit=8):\n", - " S = np.zeros(X.shape[0])\n", - " n, pdotn, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"size\"]\n", - " #powers = np.power(2, np.arange(limit+1))\n", - " for xi in range(X.shape[0]):\n", - " e = 0\n", - " ni = np.zeros(len(trees), dtype='int')\n", - " w = X[xi].dot(n[:, 0].T) < pdotn[:, 0]\n", - " ni[w] += 1\n", - " ni[~w] += 2**(limit-e)\n", - " tidx = np.arange(trees.shape[0])\n", - " for e in range(1, limit):\n", - " w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", - " ni[w] += 1\n", - " ni[~w] += 2**(limit-e)\n", - " sel = sizes[tidx, ni]>1\n", - " S[xi] += e*(~sel).sum()\n", - " tidx, ni = tidx[sel], ni[sel]\n", - " # the size matters only at terminal nodes\n", - " size = sizes[tidx, ni]\n", - " S[xi] += e*len(ni) + c_factor(size[size>1])\n", - " return S * 1. / len(trees)\n", - "\n", - "%timeit score_samples_by_sample_all1(X, trees, F3.limit)\n", - "S2 = score_samples_by_sample_all2(X, trees, F3.limit); S2\n", - "#3.512636 , 8.05164026, 10.16188574, ..., 8.66337866," - ] - }, - { - "cell_type": "code", - "execution_count": 268, - "metadata": {}, - "outputs": [], - "source": [ - "%lprun -f score_samples_by_sample_all2 score_samples_by_sample_all2(X, trees)" - ] - }, - { - "cell_type": "code", - "execution_count": 275, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.42 s ± 2.68 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - }, - { - "data": { - "text/plain": [ - "array([ 4.370636 , 8.41564026, 10.27988574, ..., 8.92937866,\n", - " 9.85111035, 11.93839893])" - ] - }, - "execution_count": 275, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def score_samples_by_sample_all1(X, trees, limit=8):\n", - " S = np.zeros(X.shape[0])\n", - " n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\n", - " for xi in range(X.shape[0]):\n", - " ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", - " tidx = np.arange(trees.shape[0])\n", - " for e in range(1, limit):\n", - " w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", - " ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T)\n", - " S[xi] += e*(ni==0).sum()\n", - " tidx, ni = tidx[ni>0], ni[ni>0]\n", - " # the size matters only at terminal nodes\n", - " size = sizes[tidx, ni]\n", - " S[xi] += e*len(ni) + c_factor(size[size>1])\n", - " return S * 1. / len(trees)\n", - "\n", - "%timeit score_samples_by_sample_all1(X, trees, F3.limit)\n", - "# 1.4 s ± 3.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "S1 = score_samples_by_sample_all1(X, trees, F3.limit); S1" - ] - }, { "cell_type": "code", "execution_count": 276, @@ -783,81 +581,6 @@ "%lprun -f score_samples_by_sample_all1 score_samples_by_sample_all1(X, trees)" ] }, - { - "cell_type": "code", - "execution_count": 277, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([False, True, False, False, True, True, False, True, False,\n", - " True, False, True, False, False, True, True, False, False,\n", - " True, False, False, False, False, True, True, True, False,\n", - " True, False, True, False, False, True, True, True, True,\n", - " True, True, True, True, True, False, True, False, False,\n", - " True, False, True, True, True, False, False, False, False,\n", - " False, False, False, False, True, True, True, False, False,\n", - " False, False, False, True, True, False, True, False, False,\n", - " False, True, False, True, True, True, False, False, False,\n", - " False, False, False, False, True, False, True, True, False,\n", - " True, True, False, False, False, False, False, True, False,\n", - " True, False, True, False, False, True, False, False, False,\n", - " False, False, False, True, True, False, False, True, True,\n", - " False, False, False, False, True, True, False, False, False,\n", - " True, True, False, True, True, False, False, False, False,\n", - " False, True, False, False, True, False, False, False, True,\n", - " False, True, False, False, True, True, True, True, False,\n", - " False, False, False, False, False, False, True, False, False,\n", - " True, True, False, False, True, False, False, False, False,\n", - " False, True, False, False, True, True, False, False, True,\n", - " False, True, True, True, True, True, False, False, True,\n", - " True, True, False, False, False, True, True, False, True,\n", - " False, False, True, False, True, True, True, False, True,\n", - " True, True, False, True, False, True, False, False, False,\n", - " False, False, True, True, True, True, True, False, False,\n", - " True, False, False, False, True, False, True, False, True,\n", - " False, False, False, False, False, False, True, False, True,\n", - " True, True, False, False, False, False, True, True, True,\n", - " True, False, True, False, True, True, True, False, True,\n", - " True, True, False, False, True, True, False, True, True,\n", - " False, True, False, False, False, False, False, True, False,\n", - " True, False, True, True, False, False, True, True, False,\n", - " True, False, False, True, False, True, False, True, True,\n", - " True, True, True, False, False, True, True, False, False,\n", - " False, False, True, False, False, True, False, False, True,\n", - " False, True, False, True, True, True, False, True, False,\n", - " False, True, True, True, True, True, False, False, True,\n", - " True, True, True, False, True, True, True, False, False,\n", - " True, False, False, False, False, False, True, False, False,\n", - " False, False, False, False, False, False, False, True, True,\n", - " True, False, True, True, False, False, False, False, False,\n", - " True, True, False, False, True, True, True, True, False,\n", - " True, True, True, True, False, False, False, True, True,\n", - " True, False, False, True, True, False, False, True, True,\n", - " True, True, False, False, False, False, True, True, False,\n", - " False, False, False, True, True, True, True, True, True,\n", - " False, False, True, False, True, True, False, False, False,\n", - " True, False, False, False, True, True, False, True, False,\n", - " False, False, True, True, False, False, True, True, True,\n", - " True, False, False, True, True, False, True, True, False,\n", - " False, False, False, False, False, True, False, True, False,\n", - " False, True, False, True, True, True, False, False, False,\n", - " True, True, False, True, False, False, False, True, False,\n", - " True, False, True, True, False, True, False, True, False,\n", - " False, False, True, True, True, False, True, False, True,\n", - " True, False, False, False, True])" - ] - }, - "execution_count": 277, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "w" - ] - }, { "cell_type": "code", "execution_count": 278, @@ -873,49 +596,6 @@ "tidx = np.arange(trees.shape[0])" ] }, - { - "cell_type": "code", - "execution_count": 290, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((5000, 3), (500, 3), (5000, 500))" - ] - }, - "execution_count": 290, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "w = X.dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni]\n", - "X.shape, trees[\"n\"][tidx, ni].T.shape, w.shape\n" - ] - }, - { - "cell_type": "code", - "execution_count": 292, - "metadata": {}, - "outputs": [ - { - "ename": "IndexError", - "evalue": "boolean index did not match indexed array along dimension 1; dimension is 3 but corresponding boolean dimension is 500", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#w[:10,:10]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mX\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mw\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mIndexError\u001b[0m: boolean index did not match indexed array along dimension 1; dimension is 3 but corresponding boolean dimension is 500" - ] - } - ], - "source": [ - "#w[:10,:10]\n", - "#X[w]" - ] - }, { "cell_type": "code", "execution_count": null, @@ -986,103 +666,6 @@ "X.shape, trees[\"n\"][tidx, ni].T.shape, X.dot(trees[\"n\"][tidx, ni].T).shape" ] }, - { - "cell_type": "code", - "execution_count": 287, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([256, 1, 256, 1, 1, 1, 1, 256, 1, 1, 1, 1, 1,\n", - " 1, 256, 256, 256, 1, 1, 256, 1, 1, 256, 1, 1, 256,\n", - " 256, 256, 1, 256, 256, 256, 1, 1, 1, 1, 256, 1, 256,\n", - " 1, 1, 1, 256, 1, 1, 1, 256, 1, 1, 1, 256, 1,\n", - " 1, 1, 256, 1, 1, 256, 1, 1, 1, 256, 1, 256, 1,\n", - " 256, 1, 1, 256, 256, 1, 1, 1, 256, 256, 256, 1, 256,\n", - " 1, 1, 1, 1, 256, 256, 256, 256, 1, 1, 256, 1, 256,\n", - " 256, 1, 1, 1, 256, 1, 1, 256, 1, 1, 1, 256, 256,\n", - " 256, 1, 1, 1, 1, 1, 256, 1, 1, 1, 256, 1, 256,\n", - " 1, 1, 1, 1, 1, 1, 1, 1, 1, 256, 256, 1, 1,\n", - " 1, 256, 1, 256, 256, 1, 1, 1, 1, 1, 1, 1, 1,\n", - " 1, 256, 1, 1, 1, 256, 1, 256, 256, 1, 256, 1, 1,\n", - " 1, 256, 1, 1, 1, 1, 256, 256, 256, 256, 1, 256, 1,\n", - " 256, 1, 256, 1, 1, 1, 1, 256, 256, 1, 256, 1, 1,\n", - " 256, 256, 256, 1, 256, 256, 256, 1, 1, 256, 256, 256, 256,\n", - " 256, 1, 1, 1, 1, 256, 256, 256, 256, 1, 256, 1, 256,\n", - " 1, 1, 256, 1, 256, 1, 256, 1, 256, 1, 1, 256, 256,\n", - " 1, 1, 256, 256, 256, 1, 256, 256, 1, 1, 256, 256, 1,\n", - " 256, 1, 1, 256, 256, 1, 256, 256, 1, 256, 1, 1, 1,\n", - " 256, 256, 256, 1, 1, 256, 1, 1, 256, 256, 1, 256, 1,\n", - " 256, 1, 256, 1, 256, 1, 1, 1, 1, 1, 256, 1, 1,\n", - " 1, 1, 1, 256, 1, 1, 256, 1, 256, 1, 1, 256, 1,\n", - " 256, 256, 1, 256, 1, 1, 256, 1, 256, 256, 256, 256, 1,\n", - " 256, 256, 256, 1, 256, 1, 1, 256, 1, 256, 1, 256, 1,\n", - " 1, 256, 256, 1, 1, 256, 256, 256, 256, 256, 256, 256, 1,\n", - " 1, 256, 256, 1, 256, 256, 1, 256, 256, 1, 256, 256, 256,\n", - " 1, 256, 1, 256, 1, 256, 1, 1, 256, 1, 1, 256, 256,\n", - " 1, 1, 1, 256, 256, 256, 1, 1, 256, 1, 1, 256, 256,\n", - " 256, 1, 1, 256, 256, 256, 256, 256, 1, 1, 1, 1, 256,\n", - " 1, 256, 256, 256, 1, 1, 1, 1, 1, 256, 1, 256, 256,\n", - " 1, 256, 256, 256, 1, 1, 256, 256, 256, 1, 1, 256, 1,\n", - " 1, 1, 256, 256, 256, 256, 1, 256, 256, 1, 1, 256, 1,\n", - " 1, 1, 1, 256, 1, 256, 256, 1, 256, 1, 1, 1, 1,\n", - " 256, 256, 1, 1, 1, 1, 1, 1, 1, 256, 256, 256, 1,\n", - " 256, 256, 256, 256, 1, 1, 256, 256, 256, 1, 1, 1, 1,\n", - " 1, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,\n", - " 1, 1, 256, 256, 1, 1, 256, 256, 256, 1, 1, 256, 256,\n", - " 256, 1, 1, 256, 1, 1, 1, 256, 256, 256, 1, 256, 1,\n", - " 1, 1, 256, 1, 256, 1], dtype=uint16),\n", - " array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,\n", - " 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,\n", - " 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,\n", - " 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,\n", - " 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,\n", - " 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,\n", - " 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,\n", - " 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,\n", - " 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,\n", - " 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,\n", - " 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,\n", - " 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155,\n", - " 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,\n", - " 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,\n", - " 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,\n", - " 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,\n", - " 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220,\n", - " 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233,\n", - " 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246,\n", - " 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,\n", - " 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,\n", - " 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,\n", - " 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298,\n", - " 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311,\n", - " 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,\n", - " 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337,\n", - " 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350,\n", - " 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363,\n", - " 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376,\n", - " 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389,\n", - " 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402,\n", - " 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415,\n", - " 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428,\n", - " 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441,\n", - " 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454,\n", - " 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467,\n", - " 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,\n", - " 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493,\n", - " 494, 495, 496, 497, 498, 499]))" - ] - }, - "execution_count": 287, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#ni, tidx, " - ] - }, { "cell_type": "code", "execution_count": 279, @@ -1145,124 +728,6 @@ "S[xi] += e*len(ni) + c_factor(size[size>1])" ] }, - { - "cell_type": "code", - "execution_count": 169, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.48 s ± 6.93 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], - "source": [ - "def score_samples_by_sample_all2(X, trees, limit=8):\n", - " S = np.zeros(X.shape[0])\n", - " n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\n", - " for xi in range(X.shape[0]):\n", - " ni = 0\n", - " tidx = np.arange(trees.shape[0])\n", - " w = X[xi].dot(n[:, ni].T) < pdotn[:, ni]\n", - " _w = np.empty_like(w)\n", - " l = r = 0\n", - " for e in range(1, limit):\n", - " l, r = left[0, l], right[0, r]\n", - " _w[w] = X[xi].dot(n[tidx[w], l].T) < pdotn[tidx[w], l]\n", - " _w[~w] = X[xi].dot(n[tidx[~w], r].T) < pdotn[tidx[~w], r]\n", - " ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T)\n", - " S[xi] += e*(ni==0).sum()\n", - " tidx, ni = tidx[ni>0], ni[ni>0]\n", - " # the size matters only at terminal nodes\n", - " size = sizes[tidx, ni]\n", - " S[xi] += e*len(ni) + c_factor(size[size>1])\n", - " return S * 1. / len(trees)\n", - "\n", - "%timeit score_samples_by_sample_all1(X, trees, F3.limit)" - ] - }, - { - "cell_type": "code", - "execution_count": 219, - "metadata": {}, - "outputs": [], - "source": [ - "#n, pdotn, childs, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"childs\"], trees[\"size\"]\n", - "xi = ni = 0\n", - "e = 1\n", - "tidx = np.arange(trees.shape[0])\n", - "w = X[xi].dot(trees[\"n\"][:, ni].T) < trees[\"pdotn\"][:, ni]\n", - "_w = np.empty_like(w)\n", - "l = r = 0" - ] - }, - { - "cell_type": "code", - "execution_count": 223, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "((500,), (500,), 268)" - ] - }, - "execution_count": 223, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "w.shape, tidx.shape, w.sum() #((500,), (500,), 268)\n", - "#trees[\"left\"][tidx[w], l]" - ] - }, - { - "cell_type": "code", - "execution_count": 225, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1 [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", - " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", - " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", - " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", - " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", - " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", - " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", - " 1 1 1 1 1 1 1 1 1] [256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256] 231\n" - ] - } - ], - "source": [ - "l, r = trees[\"left\"][tidx[w], l], trees[\"right\"][tidx[~w], r] #trees[\"childs\"][l] # trees[\"childs\"][0, l] \n", - "_w[w] = X[xi].dot(trees[\"n\"][tidx[w], l].T) < trees[\"pdotn\"][tidx[w], l]\n", - "_w[~w] = X[xi].dot(trees[\"n\"][tidx[~w], r].T) < trees[\"pdotn\"][tidx[~w], r]\n", - "w = _w\n", - "\n", - "#S[xi] += e*(ni==0).sum()\n", - "#tidx, ni = tidx[ni>0], ni[ni>0]\n", - "print(e, l, r, w.sum())\n", - "e += 1\n" - ] - }, { "cell_type": "code", "execution_count": 226, @@ -1410,47 +875,6 @@ "%prun score_samples_by_sample(X, trees)" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def score_samples_by_tree(X, trees):\n", - " S = np.zeros(X.shape[0])\n", - " for ti in range(len(trees)):\n", - " ni = 0\n", - " xidx = np.arange(X.shape[0])\n", - " for e in range(F3.limit+1):\n", - " pni = ni\n", - " ni = np.where(X.dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni], trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", - " tidx, ni = tidx[ni>0], ni[ni>0]\n", - " S[xi] += e*len(ni<1) # + c_factor(size) #trees[tidx[ni<1], pni[ni<1]][[\"size\", \"e\"]]\n", - " return S\n", - "\n", - "%timeit score_sample_by_sample(X, trees) #1.64 s ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)" - ] - }, - { - "cell_type": "code", - "execution_count": 235, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[]\n" - ] - } - ], - "source": [ - "pni = ni\n", - "ni = np.where(X[xi].dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni], trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", - "print(trees[tidx[ni<1], pni[ni<1]][[\"size\", \"e\"]]) #ni.shape, ni[:10])#, trees[tidx[ni<1], ni[ni<1]][\"e\"])\n", - "tidx, ni = tidx[ni>0], ni[ni>0]\n" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/eif_new.py b/eif_new.py index ca5ad39..6bcdd3c 100644 --- a/eif_new.py +++ b/eif_new.py @@ -33,15 +33,13 @@ class iForest(object): Parameters ---------- - X : 2D array (samples, features) - Data to be trained on. ntrees : int, default=200 Number of trees in the forest. sample : int, default=min(256, X.shape[1]) Size of the sample to be used for tree creation. limit : int, default=int(np.ceil(np.log2(sample))) Maximum depth a tree can have. - exlevel: int, default=0 + exlevel: int, default=X.shape[1]-1 Extension level to be used in the creating splitting critera. random_state: int, default=None Controls the pseudo-randomness of the selection of the feature @@ -50,173 +48,174 @@ class iForest(object): Attributes ---------- - Trees : list - A list of fitted tree objects. + trees : numpy array storing tree information Methods ------- + fit(X) + Trains ensemble of trees on data X. + score_samples(X) Computes the anomaly scores for data X. """ - def __init__(self, X, ntrees=200, sample=256, limit=None, exlevel=0, random_state=None): - self.exlevel = exlevel - if self.exlevel < 0 or self.exlevel >= X.shape[1]: - raise Exception("Extension level has to be an integer between 0 and %s."%(X.shape[1]-1,)) + def __init__(self, ntrees=200, sample=256, limit=None, exlevel=None, random_state=None): # define random seed if random_state is not None: np.random.seed(random_state) - + self.exlevel = exlevel + self.sample = sample + self.limit = limit self.ntrees = ntrees - self.sample = min(sample, X.shape[0]) - self.compute_paths = self.score_samples1 - # Set limit to the default as specified by the paper (average depth of unsuccesful search through a binary tree). - self.limit = limit if limit else int(np.ceil(np.log2(self.sample))) - # This loop builds an ensemble of iTrees (the forest). - idx = np.random.choice(X.shape[0], (self.ntrees, self.sample)) - self.Trees = [iTree(X[idx[i]], self.limit, self.exlevel) for i in range(self.ntrees)] - #self.Trees = [iTree(X[np.random.choice(X.shape[0], self.sample, replace=False)], self.limit, self.exlevel) for i in range(self.ntrees)] - - def score_samples1(self, X): - """ - Compute anomaly scores for all data points in a dataset X. + self.compute_paths = self.score_samples + + def fit(self, X): + """ Fit the ensemble of trees on data from X. Parameters ---------- X: 2D array (samples, features) - Data to be scored on. - + Data to be trained on. + Returns ------- - S: 1D array (X.shape[0]) - Anomaly scores calculated for all samples from all trees. + iForest trained on dataset X. """ - S = np.zeros(X.shape[0]) - trees = np.array([t.nodes for t in self.Trees]) - n, pdotn, left, right, sizes = trees["n"], trees["pdotn"], trees["left"], trees["right"], trees["size"] - for xi in range(X.shape[0]): - ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T) - tidx = np.arange(trees.shape[0]) - for e in range(1, self.limit): - w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni] - ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T) - S[xi] += e*(ni==0).sum() - tidx, ni = tidx[ni>0], ni[ni>0] - # the size matters only at terminal nodes - size = sizes[tidx, ni] - S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum() - S *= 1. / len(trees) - S = 2.0**(-S / c_factor(self.sample)) - return S - - def score_samples0(self, X): - Eh = np.zeros(X.shape[0]) - for t in self.Trees: - t.get_paths(X=X) - Eh += t.scores - del t.scores - Eh *= 1.0 / self.ntrees - S = 2.0**(-Eh / c_factor(self.sample)) - return S - -class iTree(object): - - """ - A single tree in the forest that is build using a unique subsample - and stored in numpy array. - - Attributes - ---------- - nodes: 2D array of shape (nodes, (n, pdotn, (left_child, right_child), size)) - An array storing tree structure and all information for splits. - dim: int - number of features - limit: int - max tree depth - exlevel: int - Exention level to be used in the creating splitting critera. - - Methods - ------- - get_paths(X) - Get tree depth reach for every sample from X and save it into self.scores. - """ - - def __init__(self, X, limit, exlevel): - self.limit = limit + # initialise variables based on X + self.sample = min(self.sample, X.shape[0]) self.dim = X.shape[1] - self.exlevel = exlevel - # for each split there can be n^2 new nodes, - # so in total sum(2^0, 2^1, ... 2^n) where n=limit+2 - maxtreei = 2**(self.limit+1)-1 + if self.exlevel is None: + self.exlevel = self.dim-1 + # 0 < exlevel < X.shape[1] + if self.exlevel < 0 or self.exlevel >= self.dim: + raise Exception("Extension level has to be an integer between 0 and %s."%(self.dim-1,)) + # Set limit to the default as specified by the paper (average depth of unsuccesful search through a binary tree). + if not self.limit: + self.limit = int(np.ceil(np.log2(self.sample))) # sample from normal distribution in order to save time later - self.normal = np.random.normal(0, 1, size=(maxtreei, self.dim)) - self.uniform = np.random.uniform(size=(maxtreei, self.dim)) + maxtreei = 2**(self.limit+1)-1 + self.normal = np.random.normal(0, 1, size=(self.ntrees, maxtreei, self.dim)) + self.uniform = np.random.uniform(size=(self.ntrees, maxtreei, self.dim)) if self.dim-self.exlevel-1: # shit, this may have replacements :/ - self.choice = np.random.choice(self.dim, size=(maxtreei, self.dim-self.exlevel-1)) - # store all nodes in single array - here probably f2 would be more than enough + self.choice = np.random.choice(self.dim, size=(self.ntrees, maxtreei, self.dim-self.exlevel-1)) + # populate trees dtype = [("n", "%sf4"%self.dim), ("pdotn", "f4"), ("left", "u2"), ("right", "u2"), ("size", "u2")] - self.nodes = np.zeros(maxtreei, dtype=dtype) - # track array population - self.treei = -1 - self._populate_nodes(X) - # trim unused nodes - #self.nodes = self.nodes[:self.treei+1] + self.trees = np.zeros((self.ntrees, maxtreei), dtype=dtype) + #idx = np.random.choice(X.shape[0], (self.ntrees, self.sample)) + for i in range(self.ntrees): + self.treei = i + self.nodei = -1 + self.populate_nodes(X[np.random.choice(X.shape[0], self.sample, replace=False)]) # clean-up - del self.normal, self.uniform, self.treei + del self.treei, self.nodei, self.uniform, self.normal if self.dim-self.exlevel-1: del self.choice + return self - def get_paths(self, X=[], nodei=0, e=0, idx=None): - """Stores the paths as self.scores for data - based on the splitting criteria stored at each node. - """ - # initialise - if not nodei: - idx = np.arange(X.shape[0]) - self.scores = np.zeros(X.shape[0]) - # unload data - n, pdotn, left, right, size = self.nodes[nodei] - # for internal nodes - if left: - # split data accordingly to each node criteria - w = X.dot(n) < pdotn - # and process two partition in child nodes - can this be multi threaded? - self.get_paths(X[w], left, e+1, idx[w]) - self.get_paths(X[~w], right, e+1, idx[~w]) - # store information from terminal nodes - elif size>1: - self.scores[idx] = e + c_factor(size) if size>1 else 0 - else: - self.scores[idx] = e #+ c_factor(size) if size>1 else 0 - - def _populate_nodes(self, X, e=0): + def populate_nodes(self, X, e=0): """Builds the tree recursively from a given node (e). By default starts from root note (e=0) """ - self.treei += 1 + self.nodei += 1 # for terminal nodes store only the size of dataset at final split if e==self.limit or len(X)<2: - self.nodes["size"][self.treei] = len(X) + self.trees["size"][self.treei, self.nodei] = len(X) # and make sure all trees have nodes in identical positions/order in the array - if e0], ni[ni>0] + #if not len(ni): break + # store number trees for which the deepest node was reached + # and their sizes (size matters only at terminal nodes) + size = sizes[tidx, ni] + S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum() + # divide by total number of trees in the fores + S *= 1. / len(trees) + # and calculate anomaly scores + S = 2.0**(-S / c_factor(self.sample)) + return S + + def score_samples_without_using_childidx(self, X): + """This implementation doesn't rely on child info from trees + but its slightly slower than the default (~7%). + The results aren't exactly the same though. + """ + # this will store scores + S = np.zeros(X.shape[0]) + trees = self.trees + n, pdotn, sizes = trees["n"], trees["pdotn"], trees["size"] + #powers = np.power(2, np.arange(self.limit+1)) + # iterate over samples + for xi in range(X.shape[0]): + ni = np.zeros(len(trees), dtype='int') + w = X[xi].dot(n[:, 0].T) < pdotn[:, 0] + ni[w] += 1 + ni[~w] += 2**self.limit + tidx = np.arange(trees.shape[0]) + for e in range(1, self.limit): + w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni] + ni[w] += 1 + ni[~w] += 2**(self.limit-e) + sel = sizes[tidx, ni]>1 + S[xi] += e*(~sel).sum() + tidx, ni = tidx[sel], ni[sel] + # the size matters only at terminal nodes + size = sizes[tidx, ni] + S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum() + # divide by total number of trees in the fores + S *= 1. / len(trees) + # and calculate anomaly scores + S = 2.0**(-S / c_factor(self.sample)) + return S From c3dce92474a39c699b3735d17c027b09d858a2b1 Mon Sep 17 00:00:00 2001 From: Leszek Date: Fri, 28 Aug 2020 17:32:24 +0200 Subject: [PATCH 4/7] performance matching c++ --- Notebooks/comparison_py_cxx.ipynb | 663 ++++++++++++------------------ eif_new.py | 259 ++++++++---- 2 files changed, 428 insertions(+), 494 deletions(-) diff --git a/Notebooks/comparison_py_cxx.ipynb b/Notebooks/comparison_py_cxx.ipynb index 1967c1c..e090aa5 100644 --- a/Notebooks/comparison_py_cxx.ipynb +++ b/Notebooks/comparison_py_cxx.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 397, "metadata": {}, "outputs": [], "source": [ @@ -25,9 +25,18 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 398, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", @@ -38,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 343, + "execution_count": 644, "metadata": {}, "outputs": [], "source": [ @@ -57,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 400, "metadata": {}, "outputs": [], "source": [ @@ -67,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 344, + "execution_count": 645, "metadata": {}, "outputs": [], "source": [ @@ -78,14 +87,14 @@ }, { "cell_type": "code", - "execution_count": 347, + "execution_count": 646, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.947 sec, Scikit Learn\n" + "0.933 sec, Scikit Learn\n" ] } ], @@ -100,14 +109,14 @@ }, { "cell_type": "code", - "execution_count": 348, + "execution_count": 647, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1.355 sec, EIF Cython Version\n" + "1.260 sec, EIF Cython Version\n" ] } ], @@ -121,14 +130,14 @@ }, { "cell_type": "code", - "execution_count": 349, + "execution_count": 687, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "44.257 sec, EIF Old Python Version\n" + "43.727 sec, EIF Old Python Version\n" ] } ], @@ -142,14 +151,14 @@ }, { "cell_type": "code", - "execution_count": 345, + "execution_count": 719, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2.184 sec, EIF New Python Version\n" + "1.214 sec, EIF New Python Version\n" ] } ], @@ -159,15 +168,20 @@ "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, exlevel=0, random_state=rng).fit(X)\n", "S3 = F3.compute_paths(X)\n", "ee = time.time()\n", - "print('{:.3f} sec, EIF New Python Version'.format(ee-ss)) # 6.309 sec, EIF New Python Version\n", + "print('{:.3f} sec, EIF New Python Version'.format(ee-ss)) \n", + "# 6.309 sec, EIF New Python Version\n", "# 3.402 sec, EIF New Python Version score_samples0\n", "# 5.821 sec, EIF New Python Version score_samples\n", - "# 2.097 sec, EIF New Python Version score_samples1 5000x3" + "# 2.097 sec, EIF New Python Version score_samples1 5000x3\n", + "# 1.603 sec, EIF New Python Version\n", + "# 1.314 sec, EIF New Python Version without using childs\n", + "# 1.300 sec, EIF New Python Version without using childs\n", + "# 1.219 sec, EIF New Python Version" ] }, { "cell_type": "code", - "execution_count": 346, + "execution_count": 689, "metadata": {}, "outputs": [ { @@ -176,13 +190,13 @@ "Text(0.5, 0, 'Scores')" ] }, - "execution_count": 346, + "execution_count": 689, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -205,14 +219,14 @@ }, { "cell_type": "code", - "execution_count": 107, + "execution_count": 672, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0:00:00.082970 5.49 Mb\n" + "0:00:00.005211 4.39 Mb\n" ] } ], @@ -228,7 +242,8 @@ "print(\"%s %.2f Mb\"%(dt, os.stat(jbl_fn).st_size/1024**2)) # 0:00:00.877536 0.56 Mb\n", "# 0:00:00.407903 0.28 Mb f2 0.44 Mb f4\n", "# 0:00:00.079145 5.49 Mb f4 u2\n", - "# 0:00:00.079248 6.95 Mb f4 i4" + "# 0:00:00.079248 6.95 Mb f4 i4\n", + "# 0:00:00.005211 4.39 Mb f4 u2 without using childs" ] }, { @@ -256,314 +271,155 @@ }, { "cell_type": "code", - "execution_count": 356, - "metadata": {}, - "outputs": [], - "source": [ - "import eif_new as iso_new\n", - "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X)\n", - "#S3 = F3.compute_paths(X)" - ] - }, - { - "cell_type": "code", - "execution_count": 357, + "execution_count": 715, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "698 ms ± 1.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "1.52 s ± 6.36 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "922 ns ± 6.82 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n", + "1.2 µs ± 8.26 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n" ] } ], "source": [ - "%timeit iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X) #X.shape[1]-1)\n", - "%timeit F3.compute_paths(X)\n", - "# 749 ms ± 3.63 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) exlevel=0\n", - "# 361 ms ± 4.18 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) without p *min-max\n", - "\n", - "# 2.46 s ± 1.84 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 1.75 s ± 5.51 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) nonzero instead of argwhere\n", - "# 1.65 s ± 17 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) without nonzero\n", - "# 1.36 s ± 4.45 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) X.dot for all nodes\n", - "# 1.99 s ± 126 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) get_paths0\n", + "@jit\n", + "def power2(n):\n", + " \"\"\"Return 2^n\"\"\"\n", + " return 2**n\n", "\n", - "# 752 ms ± 10.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) exlevel=2\n", - "# 2.48 s ± 22.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) \n", - "\n", - "#707 ms ± 5.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "#1.51 s ± 7.27 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "%timeit power2(np.arange(50))\n", + "%timeit np.power(2, np.arange(50))" ] }, { "cell_type": "code", - "execution_count": 340, - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "too many values to unpack (expected 5)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mtrees\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnodes\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mt\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTrees\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;31m#n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpdotn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mleft\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mright\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msizes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrees\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"n\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"pdotn\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"left\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"right\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"size\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 9\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mxi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m#X.shape[0]):\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: too many values to unpack (expected 5)" - ] - } - ], - "source": [ - "def c_factor(n):\n", - " return np.sum(2.0*(np.log(n-1)+0.5772156649) - (2.0*(n-1.)/(n*1.0)))\n", - "\n", - "self = F3\n", - "S = np.zeros(X.shape[0])\n", - "trees = np.array([t.nodes for t in self.Trees])\n", - "#n, pdotn, left, right, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"left\"], trees[\"right\"], trees[\"size\"]\n", - "n, pdotn, left, right, sizes = trees[[\"n\", \"pdotn\", \"left\", \"right\", \"size\"]]\n", - "\n", - "for xi in range(1): #X.shape[0]):\n", - " ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", - " tidx = np.arange(trees.shape[0])\n", - " for e in range(1, self.limit):\n", - " w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", - " ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T)\n", - " S[xi] += e*(ni==0).sum()\n", - " print(e, (ni==0).sum(), S[xi], len(ni))\n", - " tidx, ni = tidx[ni>0], ni[ni>0]\n", - " # the size matters only at terminal nodes\n", - " size = sizes[tidx, ni]\n", - " S[xi] += self.limit*len(ni) + c_factor(size[size>1])#.sum()\n", - " print(self.limit, (ni==0).sum(), S[xi], len(ni), size)" - ] - }, - { - "cell_type": "code", - "execution_count": 359, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.68 s ± 5.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], - "source": [ - "def score_samples_without_childidx(X, trees, limit=8):\n", - " S = np.zeros(X.shape[0])\n", - " n, pdotn, sizes = trees[\"n\"], trees[\"pdotn\"], trees[\"size\"]\n", - " #powers = np.power(2, np.arange(limit+1))\n", - " for xi in range(X.shape[0]):\n", - " e = 0\n", - " ni = np.zeros(len(trees), dtype='int')\n", - " w = X[xi].dot(n[:, 0].T) < pdotn[:, 0]\n", - " ni[w] += 1\n", - " ni[~w] += 2**(limit-e)\n", - " tidx = np.arange(trees.shape[0])\n", - " for e in range(1, limit):\n", - " w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", - " ni[w] += 1\n", - " ni[~w] += 2**(limit-e)\n", - " sel = sizes[tidx, ni]>1\n", - " S[xi] += e*(~sel).sum()\n", - " tidx, ni = tidx[sel], ni[sel]\n", - " # the size matters only at terminal nodes\n", - " size = sizes[tidx, ni]\n", - " S[xi] += limit*len(ni) + c_factor(size[size>1])#.sum()\n", - " return S * 1. / len(trees)\n", - "\n", - "%timeit score_samples_without_childidx(X, trees)" - ] - }, - { - "cell_type": "code", - "execution_count": 306, + "execution_count": 710, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.97761337, 0.66105967, 0.51744501, ..., 0.6299805 , 0.55715247,\n", - " 0.43243751])" + "True" ] }, - "execution_count": 306, + "execution_count": 710, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "S = F3.score_samples(X); S" + "1/200/3 == 1/200 *1/3" ] }, { "cell_type": "code", - "execution_count": 307, + "execution_count": 718, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.74400223, 0.56587012, 0.4988135 , ..., 0.54653904, 0.5134962 ,\n", - " 0.44586648])" - ] - }, - "execution_count": 307, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "S1 = F3.score_samples1(X); S1" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "( C_CONTIGUOUS : True\n", - " F_CONTIGUOUS : False\n", - " OWNDATA : True\n", - " WRITEABLE : True\n", - " ALIGNED : True\n", - " WRITEBACKIFCOPY : False\n", - " UPDATEIFCOPY : False,\n", - " dtype([('n', '0], ni[ni>0]\n", - "e += 1" - ] + "source": [] }, { "cell_type": "code", - "execution_count": 284, + "execution_count": 654, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "10 µs ± 21.3 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n" + "The line_profiler extension is already loaded. To reload it, use:\n", + " %reload_ext line_profiler\n" ] - }, - { - "data": { - "text/plain": [ - "((3,), (3, 500), (500,))" - ] - }, - "execution_count": 284, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "[trees[[\"left\", \"right\"]][:, 0]]\n", - "%timeit X[xi].dot(trees[\"n\"][tidx, ni].T).shape\n", - "X[xi].shape, trees[\"n\"][tidx, ni].T.shape, X[xi].dot(trees[\"n\"][tidx, ni].T).shape" + "#!pip install line_profiler\n", + "%load_ext line_profiler\n", + "#%lprun -f F3.populate_nodes F3.fit(X)\n", + "%lprun -f F3.score_samples_without_using_childidx F3.score_samples_without_using_childidx(X)" ] }, { "cell_type": "code", - "execution_count": 283, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "3.78 ms ± 81.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" - ] - }, - { - "data": { - "text/plain": [ - "((5000, 3), (3, 500), (5000, 500))" - ] - }, - "execution_count": 283, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "%timeit X.dot(trees[\"n\"][tidx, ni].T).shape\n", - "X.shape, trees[\"n\"][tidx, ni].T.shape, X.dot(trees[\"n\"][tidx, ni].T).shape" + " 243 5000 36145.0 7.2 2.2 ni[w] += 1\n", + " 244 5000 34944.0 7.0 2.1 ni[~w] += 2**self.limit\n", + " 245 5000 13052.0 2.6 0.8 tidx = np.arange(trees.shape[0])\n", + " 246 40000 20187.0 0.5 1.2 for e in range(1, self.limit):\n", + " 247 35000 503963.0 14.4 30.4 w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", + " 248 35000 224162.0 6.4 13.5 ni[w] += 1\n", + " 249 35000 231092.0 6.6 13.9 ni[~w] += 2**(self.limit-e)\n", + " 250 35000 153654.0 4.4 9.3 sel = sizes[tidx, ni]>1\n", + " 251 35000 199838.0 5.7 12.0 S[xi] += e*(~sel).sum()\n", + " 252 35000 90068.0 2.6 5.4 tidx, ni = tidx[sel], ni[sel]\n", + " 253 # the size matters only at terminal nodes\n", + " 254 5000 13812.0 2.8 0.8 size = sizes[tidx, ni]\n", + " 255 5000 74718.0 14.9 4.5 S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum()\n", + "\n", + "\n", + " 245 5000 8827.0 1.8 0.7 ni = update_nodes(ni, w, self.limit, 0)\n", + " 251 35000 55862.0 1.6 4.4 ni = update_nodes(ni, w, self.limit, e) \n", + "\n", + " 248 35000 66392.0 1.9 6.3 S[xi] += score_false(e, sel) #e*(~sel).sum()\n", + " 252 5000 49817.0 10.0 4.0 S[xi] += score_terminal(self.limit, ni, size) #self.limit*len(ni) + c_factor(size[size>1]).sum()\n" ] }, { "cell_type": "code", - "execution_count": 279, + "execution_count": 666, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0 0 [256 1 256 1 1 1 1 256 1 1 1 1 1 1 256 256 256 1\n", - " 1 256 1 1 256 1 1 256 256 256 1 256 256 256 1 1 1 1\n", - " 256 1 256 1 1 1 256 1 1 1 256 1 1 1 256 1 1 1\n", - " 256 1 1 256 1 1 1 256 1 256 1 256 1 1 256 256 1 1\n", - " 1 256 256 256 1 256 1 1 1 1 256 256 256 256 1 1 256 1\n", - " 256 256 1 1 1 256 1 1 256 1 1 1 256 256 256 1 1 1\n", - " 1 1 256 1 1 1 256 1 256 1 1 1 1 1 1 1 1 1\n", - " 256 256 1 1 1 256 1 256 256 1 1 1 1 1 1 1 1 1\n", - " 256 1 1 1 256 1 256 256 1 256 1 1 1 256 1 1 1 1\n", - " 256 256 256 256 1 256 1 256 1 256 1 1 1 1 256 256 1 256\n", - " 1 1 256 256 256 1 256 256 256 1 1 256 256 256 256 256 1 1\n", - " 1 1 256 256 256 256 1 256 1 256 1 1 256 1 256 1 256 1\n", - " 256 1 1 256 256 1 1 256 256 256 1 256 256 1 1 256 256 1\n", - " 256 1 1 256 256 1 256 256 1 256 1 1 1 256 256 256 1 1\n", - " 256 1 1 256 256 1 256 1 256 1 256 1 256 1 1 1 1 1\n", - " 256 1 1 1 1 1 256 1 1 256 1 256 1 1 256 1 256 256\n", - " 1 256 1 1 256 1 256 256 256 256 1 256 256 256 1 256 1 1\n", - " 256 1 256 1 256 1 1 256 256 1 1 256 256 256 256 256 256 256\n", - " 1 1 256 256 1 256 256 1 256 256 1 256 256 256 1 256 1 256\n", - " 1 256 1 1 256 1 1 256 256 1 1 1 256 256 256 1 1 256\n", - " 1 1 256 256 256 1 1 256 256 256 256 256 1 1 1 1 256 1\n", - " 256 256 256 1 1 1 1 1 256 1 256 256 1 256 256 256 1 1\n", - " 256 256 256 1 1 256 1 1 1 256 256 256 256 1 256 256 1 1\n", - " 256 1 1 1 1 256 1 256 256 1 256 1 1 1 1 256 256 1\n", - " 1 1 1 1 1 1 256 256 256 1 256 256 256 256 1 1 256 256\n", - " 256 1 1 1 1 1 256 256 256 256 256 256 256 256 256 256 256 256\n", - " 1 1 256 256 1 1 256 256 256 1 1 256 256 256 1 1 256 1\n", - " 1 1 256 256 256 1 256 1 1 1 256 1 256 1]\n" + "396 ms ± 4.01 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "1.24 s ± 2.89 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "915 ms ± 4.05 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] } ], "source": [ - "#for e in range(limit):\n", - "pni = ni\n", - "w = X[xi].dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni]\n", - "ni = np.where(w, trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", - "if e: S[xi] += e*(ni==0).sum()\n", - "print(e, (ni<1).sum(), ni)\n", - "tidx, ni = tidx[ni>0], ni[ni>0]\n", - "e += 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# the size matters only at terminal nodes\n", - "size = trees[\"size\"][tidx, ni]\n", - "S[xi] += e*len(ni) + c_factor(size[size>1])" + "import eif_new as iso_new #Ntrees\n", + "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X)\n", + "%timeit F3.fit(X)\n", + "%timeit F3.score_samples(X)\n", + "%timeit F3.score_samples_without_using_childidx(X)\n", + "\n", + "# 394 ms ± 5.03 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "# 1.4 s ± 2.68 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "\n", + "# 395 ms ± 4.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "# 1.25 s ± 792 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) # score_empty\n", + "\n", + "#404 ms ± 3.53 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "#926 ms ± 3.94 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "\n", + "\n", + "#393 ms ± 2.43 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "#1.22 s ± 6.65 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "\n", + "#398 ms ± 2.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "#1.21 s ± 2.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "#897 ms ± 1.82 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" ] }, { "cell_type": "code", - "execution_count": 226, + "execution_count": 667, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "((500,), (500,), (268,), 231)" - ] - }, - "execution_count": 226, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "The line_profiler extension is already loaded. To reload it, use:\n", + " %reload_ext line_profiler\n" + ] } ], "source": [ - "w.shape, tidx.shape, l.shape, w.sum() #((500,), (500,), 268)\n", - "#trees[\"left\"][tidx[w], l]" + "#!pip install line_profiler\n", + "%load_ext line_profiler\n", + "#%lprun -f F3.populate_nodes F3.fit(X)\n", + "%lprun -f F3.score_samples F3.score_samples(X)" ] }, { "cell_type": "code", - "execution_count": 189, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 1, 256], dtype=uint16)" - ] - }, - "execution_count": 189, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "trees[\"childs\"][0, l]" + " 197 5000 70606.0 14.1 4.4 ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", + " 203 35000 393205.0 11.2 24.7 ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T) \n", + "\n", + "\n", + " 197 5000 60670.0 12.1 3.8 ni = where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", + " 203 35000 384696.0 11.0 24.0 ni = where(w, left[tidx, ni].T, right[tidx, ni].T) \n", + "\n", + " 205 35000 228445.0 6.5 14.8 S[xi] += e*(ni==0).sum()\n", + " 210 35000 64396.0 1.8 4.7 S[xi] += score_empty(e, ni) #e*(ni==0).sum()\n", + "\n", + " 217 5000 82895.0 16.6 6.0 S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum()\n", + " 222 5000 49138.0 9.8 3.7 S[xi] += score_terminal(self.limit, ni, size) #self.limit*len(ni) + c_factor(size[size>1]).sum()\n", + "\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 236, + "execution_count": 391, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The line_profiler extension is already loaded. To reload it, use:\n", - " %reload_ext line_profiler\n" - ] - } - ], + "outputs": [], "source": [ - "#!pip install line_profiler\n", - "%load_ext line_profiler\n", - "%lprun -f score_samples_by_sample_all1 score_samples_by_sample_all1(X, trees)" + "#%prun score_samples_by_sample_pool(X, trees, 6)" ] }, { @@ -877,10 +673,61 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 674, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "w = np.random.choice([True, False], size=X.shape[0]), X.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 675, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "97.6 µs ± 60.5 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n" + ] + } + ], + "source": [ + "%timeit X[w], X[~w]" + ] + }, + { + "cell_type": "code", + "execution_count": 679, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "70.8 µs ± 44.6 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n" + ] + } + ], + "source": [ + "@jit\n", + "def split(x, w):\n", + " a = np.empty_like(x)\n", + " b = np.empty_like(x)\n", + " k = l = 0\n", + " for i in range(len(x)):\n", + " if w[i]: \n", + " a[k] = x[i]\n", + " k += 1\n", + " else:\n", + " b[l] = x[i]\n", + " l += 1\n", + " return a[:k], b[:l]\n", + "\n", + "%timeit split(X, w) #70.8 µs ± 44.6 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n", + "%timeit X[w], X[~w] #97.6 µs ± 60.5 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)" + ] } ], "metadata": { diff --git a/eif_new.py b/eif_new.py index 6bcdd3c..9275dd8 100644 --- a/eif_new.py +++ b/eif_new.py @@ -9,24 +9,70 @@ import numpy as np import os from version import __version__ +from numba import jit#, float32, int32 +@jit def c_factor(n): + """Return average path length of unsuccesful search in a binary search tree + given n points. """ - Average path length of unsuccesful search in a binary search tree given n points - - Parameters - ---------- - n : int - Number of data points for the BST. - - Returns - ------- - float - Average path length of unsuccesful search in a BST - """ - #if n<2: return 0 return 2.0*(np.log(n-1)+0.5772156649) - (2.0*(n-1.)/(n*1.0)) +@jit +def minmax(x): + """np.min(x, axis=0), np.max(x, axis=0) for 2D array but faster""" + m, n = len(x), len(x[0]) + mi, ma = np.empty(n), np.empty(n) + mi[:] = ma[:] = x[0] + for i in range(1, m): + for j in range(n): + if x[i, j]>ma[j]: ma[j] = x[i, j] + elif x[i, j]1]).sum()""" + return limit*len(ni) + c_factor(size[size>1]).sum() + class iForest(object): """ Create an iForest object holding trees (iTree_array objects) trained on provided data (X). @@ -67,20 +113,17 @@ def __init__(self, ntrees=200, sample=256, limit=None, exlevel=None, random_stat self.sample = sample self.limit = limit self.ntrees = ntrees - self.compute_paths = self.score_samples + self.compute_paths = self.score_samples#_using_childs def fit(self, X): - """ Fit the ensemble of trees on data from X. + """Return iForest trained on data from X. Parameters ---------- X: 2D array (samples, features) Data to be trained on. - - Returns - ------- - iForest trained on dataset X. """ + #X = X.astype(dtype="f8") # initialise variables based on X self.sample = min(self.sample, X.shape[0]) self.dim = X.shape[1] @@ -93,57 +136,122 @@ def fit(self, X): if not self.limit: self.limit = int(np.ceil(np.log2(self.sample))) # sample from normal distribution in order to save time later - maxtreei = 2**(self.limit+1)-1 - self.normal = np.random.normal(0, 1, size=(self.ntrees, maxtreei, self.dim)) - self.uniform = np.random.uniform(size=(self.ntrees, maxtreei, self.dim)) + maxnodes = 2**(self.limit+1)-1 + self.rng = np.random.default_rng() + self.normal = np.random.normal(0, 1, size=(self.ntrees, maxnodes, self.dim)) + self.uniform = np.random.uniform(size=(self.ntrees, maxnodes, self.dim)) if self.dim-self.exlevel-1: # shit, this may have replacements :/ - self.choice = np.random.choice(self.dim, size=(self.ntrees, maxtreei, self.dim-self.exlevel-1)) + self.choice = np.random.choice(self.dim, size=(self.ntrees, maxnodes, self.dim-self.exlevel-1))#.astype(dtype="f4") # populate trees - dtype = [("n", "%sf4"%self.dim), ("pdotn", "f4"), ("left", "u2"), ("right", "u2"), ("size", "u2")] - self.trees = np.zeros((self.ntrees, maxtreei), dtype=dtype) - #idx = np.random.choice(X.shape[0], (self.ntrees, self.sample)) - for i in range(self.ntrees): - self.treei = i - self.nodei = -1 - self.populate_nodes(X[np.random.choice(X.shape[0], self.sample, replace=False)]) + dtype = [("n", "%sf4"%self.dim), ("pdotn", "f4"), ("size", "u2")]#, ("left", "u2"), ("right", "u2")] + self.trees = np.zeros((self.ntrees, maxnodes), dtype=dtype) + for treei in range(self.ntrees): + idx = np.random.choice(X.shape[0], self.sample, replace=False) + self.populate_nodes(X[idx], treei) # clean-up - del self.treei, self.nodei, self.uniform, self.normal + del self.normal, self.uniform if self.dim-self.exlevel-1: del self.choice return self - def populate_nodes(self, X, e=0): - """Builds the tree recursively from a given node (e). - By default starts from root note (e=0) + def populate_nodes(self, X, treei, nodei=0, e=0): + """Builds the tree recursively from a given node (e). + By default starts from root note (e=0) and make all trees symmetrical. """ - self.nodei += 1 # for terminal nodes store only the size of dataset at final split if e==self.limit or len(X)<2: - self.trees["size"][self.treei, self.nodei] = len(X) + self.trees["size"][treei, nodei] = len(X) + # for internal nodes store everything + else: + # A random normal vector picked form a uniform n-sphere. Note that in order to pick uniformly from n-sphere, we need to pick a random normal for each component of this vector. + n = self.normal[treei, nodei] + # Pick the indices for which the normal vector elements should be set to zero acccording to the extension level. + if self.dim-self.exlevel-1: + n[self.choice[treei, nodei]] = 0 + # Picking a random intercept point for the hyperplane splitting data. + mi, ma = minmax(X) # much faster than X.min(axis=0), X.max(axis=0) + # calculating pdotn here will make classification faster and take less space to store + pdotn = dot(scale_minmax(self.uniform[treei, nodei], mi, ma), n) + # Criteria that determines if a data point should go to the left or right child node. + w = X.dot(n) < pdotn # here X.dot(n) uses BLAS so no need to optimise ;) + # store current node + self.trees[treei, nodei] = n, pdotn, len(X) + # add left & right node + a, b = split(X, w) # faster than X[~w], X[w] + self.populate_nodes(a, treei, nodei+1, e+1) + self.populate_nodes(b, treei, nodei+2**(self.limit-e), e+1) #2**(self.limit-e) + + def score_samples(self, X): + """ + Compute anomaly scores for all data points in a dataset X. + + ---------- + X: 2D array (samples, features) + Data to be scored on. + + Returns + ------- + S: 1D array (X.shape[0]) + Anomaly scores calculated for all samples from all trees. + """ + # this will store scores + S = np.zeros(X.shape[0]) + trees = self.trees + n, pdotn, sizes = trees["n"], trees["pdotn"], trees["size"] + # iterate over samples + for xi in range(X.shape[0]): + ni = np.zeros(len(trees), dtype='int') + w = X[xi].dot(n[:, 0].T) < pdotn[:, 0] + ni = update_nodes(ni, w, self.limit, 0) + tidx = np.arange(trees.shape[0]) + for e in range(1, self.limit): + w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni] + ni = update_nodes(ni, w, self.limit, e) + sel = sizes[tidx, ni]>1 + S[xi] += score_false(e, sel) #e*(~sel).sum() + tidx, ni = tidx[sel], ni[sel] + # the size matters only at terminal nodes + size = sizes[tidx, ni] + S[xi] += score_terminal(self.limit, ni, size) #self.limit*len(ni) + c_factor(size[size>1]).sum() + # calculate anomaly scores + S = np.power(2, -S / len(trees) / c_factor(self.sample)) + return S + +''' + def populate_nodes(self, X, treei, nodei=0, e=0): + """Builds the tree recursively from a given node (e). + By default starts from root note (e=0) and make all trees symmetrical. + """ + # for terminal nodes store only the size of dataset at final split + if e==self.limit or len(X)<2: + self.trees["size"][treei, nodei] = len(X) # and make sure all trees have nodes in identical positions/order in the array - if e0], ni[ni>0] #if not len(ni): break # store number trees for which the deepest node was reached # and their sizes (size matters only at terminal nodes) size = sizes[tidx, ni] - S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum() + S[xi] += score_terminal(self.limit, ni, size) #self.limit*len(ni) + c_factor(size[size>1]).sum() # divide by total number of trees in the fores S *= 1. / len(trees) # and calculate anomaly scores S = 2.0**(-S / c_factor(self.sample)) return S - def score_samples_without_using_childidx(self, X): - """This implementation doesn't rely on child info from trees - but its slightly slower than the default (~7%). - The results aren't exactly the same though. - """ - # this will store scores - S = np.zeros(X.shape[0]) - trees = self.trees - n, pdotn, sizes = trees["n"], trees["pdotn"], trees["size"] - #powers = np.power(2, np.arange(self.limit+1)) - # iterate over samples - for xi in range(X.shape[0]): - ni = np.zeros(len(trees), dtype='int') - w = X[xi].dot(n[:, 0].T) < pdotn[:, 0] - ni[w] += 1 - ni[~w] += 2**self.limit - tidx = np.arange(trees.shape[0]) - for e in range(1, self.limit): - w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni] - ni[w] += 1 - ni[~w] += 2**(self.limit-e) - sel = sizes[tidx, ni]>1 - S[xi] += e*(~sel).sum() - tidx, ni = tidx[sel], ni[sel] - # the size matters only at terminal nodes - size = sizes[tidx, ni] - S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum() - # divide by total number of trees in the fores - S *= 1. / len(trees) - # and calculate anomaly scores - S = 2.0**(-S / c_factor(self.sample)) - return S + +@jit +def where(w, a, b): + """Return np.where(w, a, b)""" + return np.where(w, a, b) + +@jit +def score_empty(e, ni): + """Return e*(ni==0).sum()""" + return e*(ni==0).sum() +''' From 58233c6205df00e38dad5feefae536e570cded63 Mon Sep 17 00:00:00 2001 From: Leszek Date: Mon, 31 Aug 2020 17:48:29 +0200 Subject: [PATCH 5/7] performance matching c++ --- Notebooks/comparison_py_cxx.ipynb | 585 +++--------------------------- eif_new.py | 2 +- 2 files changed, 56 insertions(+), 531 deletions(-) diff --git a/Notebooks/comparison_py_cxx.ipynb b/Notebooks/comparison_py_cxx.ipynb index e090aa5..a9e0abb 100644 --- a/Notebooks/comparison_py_cxx.ipynb +++ b/Notebooks/comparison_py_cxx.ipynb @@ -2,14 +2,22 @@ "cells": [ { "cell_type": "code", - "execution_count": 397, + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install numba\n", + "from numba import jit # eif_new relies on numba jit compiled functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "#!pip install -U numba\n", - "from numba import jit\n", "from scipy.stats import multivariate_normal\n", "import random as rn\n", "import eif as iso\n", @@ -20,34 +28,18 @@ "import time\n", "import eif_old as iso2\n", "import seaborn as sb\n", - "from sklearn.ensemble import IsolationForest" - ] - }, - { - "cell_type": "code", - "execution_count": 398, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ + "from sklearn.ensemble import IsolationForest\n", + "\n", "%load_ext autoreload\n", "%autoreload 2\n", - "import sys\n", + "import sys, os\n", "sys.path.insert(0, \"../\")\n", "import eif_new as iso_new" ] }, { "cell_type": "code", - "execution_count": 644, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -66,17 +58,7 @@ }, { "cell_type": "code", - "execution_count": 400, - "metadata": {}, - "outputs": [], - "source": [ - "# Generate train data\n", - "#X = 0.3 * np.random.randn(1000, 10)" - ] - }, - { - "cell_type": "code", - "execution_count": 645, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -87,14 +69,14 @@ }, { "cell_type": "code", - "execution_count": 646, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.933 sec, Scikit Learn\n" + "0.946 sec, Scikit Learn\n" ] } ], @@ -109,14 +91,14 @@ }, { "cell_type": "code", - "execution_count": 647, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1.260 sec, EIF Cython Version\n" + "1.310 sec, EIF Cython Version\n" ] } ], @@ -130,14 +112,14 @@ }, { "cell_type": "code", - "execution_count": 687, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "43.727 sec, EIF Old Python Version\n" + "43.649 sec, EIF Old Python Version\n" ] } ], @@ -151,37 +133,32 @@ }, { "cell_type": "code", - "execution_count": 719, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "1.214 sec, EIF New Python Version\n" + "1.250 sec, EIF New Python Version\n" ] } ], "source": [ - "import eif_new as iso_new\n", + "# the first execution will compile all numba functions\n", + "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, exlevel=0, random_state=rng).fit(X[:10])\n", + "S3 = F3.compute_paths(X[:10])\n", + "# this is the valid execution\n", "ss = time.time()\n", "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, exlevel=0, random_state=rng).fit(X)\n", "S3 = F3.compute_paths(X)\n", "ee = time.time()\n", - "print('{:.3f} sec, EIF New Python Version'.format(ee-ss)) \n", - "# 6.309 sec, EIF New Python Version\n", - "# 3.402 sec, EIF New Python Version score_samples0\n", - "# 5.821 sec, EIF New Python Version score_samples\n", - "# 2.097 sec, EIF New Python Version score_samples1 5000x3\n", - "# 1.603 sec, EIF New Python Version\n", - "# 1.314 sec, EIF New Python Version without using childs\n", - "# 1.300 sec, EIF New Python Version without using childs\n", - "# 1.219 sec, EIF New Python Version" + "print('{:.3f} sec, EIF New Python Version'.format(ee-ss)) " ] }, { "cell_type": "code", - "execution_count": 689, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -190,13 +167,13 @@ "Text(0.5, 0, 'Scores')" ] }, - "execution_count": 689, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -219,515 +196,63 @@ }, { "cell_type": "code", - "execution_count": 672, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0:00:00.005211 4.39 Mb\n" - ] - } - ], - "source": [ - "import joblib, os\n", - "from datetime import datetime\n", - "ext = \"jbl\"\n", - "\n", - "t0 = datetime.now()\n", - "jbl_fn = \"eif_new.%s\"%ext\n", - "joblib.dump(F3, jbl_fn)\n", - "dt = datetime.now()-t0\n", - "print(\"%s %.2f Mb\"%(dt, os.stat(jbl_fn).st_size/1024**2)) # 0:00:00.877536 0.56 Mb\n", - "# 0:00:00.407903 0.28 Mb f2 0.44 Mb f4\n", - "# 0:00:00.079145 5.49 Mb f4 u2\n", - "# 0:00:00.079248 6.95 Mb f4 i4\n", - "# 0:00:00.005211 4.39 Mb f4 u2 without using childs" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0:00:08.227051 42.72 Mb\n" - ] - } - ], - "source": [ - "t0 = datetime.now()\n", - "jbl_fn = \"eif_old.%s\"%ext\n", - "joblib.dump(F2, jbl_fn)\n", - "dt = datetime.now()-t0\n", - "print(\"%s %.2f Mb\"%(dt, os.stat(jbl_fn).st_size/1024**2)) #0:00:32.724675 6.83 Mb\n", - "# 0:00:17.224409 3.54 Mb\n", - "# 0:00:08.227051 42.72 Mb no compression" - ] - }, - { - "cell_type": "code", - "execution_count": 715, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "922 ns ± 6.82 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n", - "1.2 µs ± 8.26 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n" + "EIF old Python Version dump size: 37.38 Mb\n", + "EIF new Python Version dump size: 4.39 Mb\n" ] } ], "source": [ - "@jit\n", - "def power2(n):\n", - " \"\"\"Return 2^n\"\"\"\n", - " return 2**n\n", - "\n", - "%timeit power2(np.arange(50))\n", - "%timeit np.power(2, np.arange(50))" - ] - }, - { - "cell_type": "code", - "execution_count": 710, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 710, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "1/200/3 == 1/200 *1/3" + "import pickle\n", + "versions = (\"old\", \"new\")\n", + "for v, obj in zip(versions, (F2, F3)):\n", + " pkl_fn = \"eif_%s.pkl\"%v\n", + " with open(pkl_fn, \"wb\") as file:\n", + " pickle.dump(obj, file)\n", + " print(\"EIF %s Python Version dump size: %.2f Mb\"%(v, os.stat(pkl_fn).st_size/1024**2,))" ] }, { "cell_type": "code", - "execution_count": 718, - "metadata": {}, - "outputs": [], - "source": [ - "import eif_new as iso_new #Ntrees\n", - "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X)\n", - "S3 = F3.compute_paths(X)" - ] - }, - { - "cell_type": "code", - "execution_count": 717, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "307 ms ± 1.08 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "922 ms ± 3.91 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "EIF old Python Version joblib dump size 3.55 Mb in 17.518 sec\n", + "EIF new Python Version joblib dump size 0.38 Mb in 0.482 sec\n" ] } ], "source": [ - "%timeit iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X) #X.shape[1]-1)\n", - "%timeit F3.compute_paths(X)\n", - "# 749 ms ± 3.63 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) exlevel=0\n", - "# 361 ms ± 4.18 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) without p *min-max\n", - "\n", - "# 2.46 s ± 1.84 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 1.75 s ± 5.51 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) nonzero instead of argwhere\n", - "# 1.65 s ± 17 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) without nonzero\n", - "# 1.36 s ± 4.45 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) X.dot for all nodes\n", - "# 1.99 s ± 126 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) get_paths0\n", - "\n", - "# 752 ms ± 10.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) exlevel=2\n", - "# 2.48 s ± 22.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) \n", - "\n", - "#707 ms ± 5.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "#1.51 s ± 7.27 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "# 623 ms ± 4.09 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 1.44 s ± 6.55 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "# 600 ms ± 561 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 1.44 s ± 15.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "# 452 ms ± 1.51 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) jit minmax\n", - "# 1.38 s ± 2.39 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "# 399 ms ± 6.08 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 1.35 s ± 2.39 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "#308 ms ± 741 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "#935 ms ± 3.23 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" + "#!pip install joblib\n", + "import joblib\n", + "versions = (\"old\", \"new\")\n", + "for v, obj in zip(versions, (F2, F3)):\n", + " jbl_fn = \"eif_%s.jbl.lzma\"%v # lzma compression\n", + " t0 = time.time()\n", + " joblib.dump(obj, jbl_fn)\n", + " dt = time.time()-t0\n", + " print(\"EIF %s Python Version joblib dump size %.2f Mb in %.3f sec\"%(v, os.stat(jbl_fn).st_size/1024**2, dt))" ] }, { "cell_type": "code", - "execution_count": 615, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "size = 500\n", - "w = np.random.choice([False, True], size=size); w\n", - "a, b = np.zeros(size), np.ones(size)\n", - "ni = np.random.choice(np.arange(511), size)\n", - "e = 3" - ] - }, - { - "cell_type": "code", - "execution_count": 653, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "925 ms ± 10.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "1.23 s ± 3.34 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], - "source": [ - "import eif_new as iso_new #Ntrees\n", - "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X)\n", - "#%timeit F3.fit(X)\n", - "%timeit F3.score_samples_without_using_childidx(X)\n", - "%timeit F3.score_samples(X)\n", - "\n", - "\n", - "# 1.25 s ± 792 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) # score_empty\n", - "# 1.55 s ± 3.45 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "# 1.79 s ± 2.23 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) update_nodes jit\n", - "# 1.43 s ± 4.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) update_nodes loop jit\n", - "# 1.09 s ± 1.83 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "# 911 ms ± 2.21 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) score jit" - ] - }, - { - "cell_type": "code", - "execution_count": 682, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The line_profiler extension is already loaded. To reload it, use:\n", - " %reload_ext line_profiler\n" - ] - } - ], - "source": [ - "#!pip install line_profiler\n", "%load_ext line_profiler\n", "%lprun -f F3.populate_nodes F3.fit(X)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 654, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The line_profiler extension is already loaded. To reload it, use:\n", - " %reload_ext line_profiler\n" - ] - } - ], - "source": [ - "#!pip install line_profiler\n", - "%load_ext line_profiler\n", - "#%lprun -f F3.populate_nodes F3.fit(X)\n", - "%lprun -f F3.score_samples_without_using_childidx F3.score_samples_without_using_childidx(X)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - " 243 5000 36145.0 7.2 2.2 ni[w] += 1\n", - " 244 5000 34944.0 7.0 2.1 ni[~w] += 2**self.limit\n", - " 245 5000 13052.0 2.6 0.8 tidx = np.arange(trees.shape[0])\n", - " 246 40000 20187.0 0.5 1.2 for e in range(1, self.limit):\n", - " 247 35000 503963.0 14.4 30.4 w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni]\n", - " 248 35000 224162.0 6.4 13.5 ni[w] += 1\n", - " 249 35000 231092.0 6.6 13.9 ni[~w] += 2**(self.limit-e)\n", - " 250 35000 153654.0 4.4 9.3 sel = sizes[tidx, ni]>1\n", - " 251 35000 199838.0 5.7 12.0 S[xi] += e*(~sel).sum()\n", - " 252 35000 90068.0 2.6 5.4 tidx, ni = tidx[sel], ni[sel]\n", - " 253 # the size matters only at terminal nodes\n", - " 254 5000 13812.0 2.8 0.8 size = sizes[tidx, ni]\n", - " 255 5000 74718.0 14.9 4.5 S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum()\n", - "\n", - "\n", - " 245 5000 8827.0 1.8 0.7 ni = update_nodes(ni, w, self.limit, 0)\n", - " 251 35000 55862.0 1.6 4.4 ni = update_nodes(ni, w, self.limit, e) \n", - "\n", - " 248 35000 66392.0 1.9 6.3 S[xi] += score_false(e, sel) #e*(~sel).sum()\n", - " 252 5000 49817.0 10.0 4.0 S[xi] += score_terminal(self.limit, ni, size) #self.limit*len(ni) + c_factor(size[size>1]).sum()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 666, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "396 ms ± 4.01 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "1.24 s ± 2.89 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "915 ms ± 4.05 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], - "source": [ - "import eif_new as iso_new #Ntrees\n", - "F3 = iso_new.iForest(ntrees=Ntrees, sample=Nsamples, random_state=rng, exlevel=0).fit(X)\n", - "%timeit F3.fit(X)\n", - "%timeit F3.score_samples(X)\n", - "%timeit F3.score_samples_without_using_childidx(X)\n", - "\n", - "# 394 ms ± 5.03 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 1.4 s ± 2.68 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "# 395 ms ± 4.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "# 1.25 s ± 792 µs per loop (mean ± std. dev. of 7 runs, 1 loop each) # score_empty\n", - "\n", - "#404 ms ± 3.53 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "#926 ms ± 3.94 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "\n", - "#393 ms ± 2.43 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "#1.22 s ± 6.65 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "\n", - "#398 ms ± 2.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "#1.21 s ± 2.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "#897 ms ± 1.82 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 667, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The line_profiler extension is already loaded. To reload it, use:\n", - " %reload_ext line_profiler\n" - ] - } - ], - "source": [ - "#!pip install line_profiler\n", - "%load_ext line_profiler\n", - "#%lprun -f F3.populate_nodes F3.fit(X)\n", - "%lprun -f F3.score_samples F3.score_samples(X)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - " 197 5000 70606.0 14.1 4.4 ni = np.where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", - " 203 35000 393205.0 11.2 24.7 ni = np.where(w, left[tidx, ni].T, right[tidx, ni].T) \n", - "\n", - "\n", - " 197 5000 60670.0 12.1 3.8 ni = where(X[xi].dot(n[:, 0].T) < pdotn[:, 0], left[:, 0].T, right[:, 0].T)\n", - " 203 35000 384696.0 11.0 24.0 ni = where(w, left[tidx, ni].T, right[tidx, ni].T) \n", - "\n", - " 205 35000 228445.0 6.5 14.8 S[xi] += e*(ni==0).sum()\n", - " 210 35000 64396.0 1.8 4.7 S[xi] += score_empty(e, ni) #e*(ni==0).sum()\n", - "\n", - " 217 5000 82895.0 16.6 6.0 S[xi] += self.limit*len(ni) + c_factor(size[size>1]).sum()\n", - " 222 5000 49138.0 9.8 3.7 S[xi] += score_terminal(self.limit, ni, size) #self.limit*len(ni) + c_factor(size[size>1]).sum()\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 391, - "metadata": {}, - "outputs": [], - "source": [ - "#%prun score_samples_by_sample_pool(X, trees, 6)" - ] - }, - { - "cell_type": "code", - "execution_count": 428, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1\n", - "2.02 s ± 771 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "2\n", - "1.07 s ± 49.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "3\n", - "740 ms ± 1.22 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "4\n", - "652 ms ± 626 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "5\n", - "562 ms ± 2.64 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "6\n", - "577 ms ± 19.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "7\n", - "587 ms ± 27.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "8\n", - "562 ms ± 49.5 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "9\n", - "543 ms ± 42.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "10\n", - "555 ms ± 43.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "11\n", - "553 ms ± 38.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "12\n", - "537 ms ± 2.07 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n" - ] - } - ], - "source": [ - "def worker(args):\n", - " Xi = args\n", - " ni = 0\n", - " S = 0\n", - " tidx = np.arange(trees.shape[0])\n", - " for e in range(F3.limit):\n", - " pni = ni\n", - " ni = np.where(Xi.dot(trees[\"n\"][tidx, ni].T) < trees[\"pdotn\"][tidx, ni], trees[\"left\"][tidx, ni].T, trees[\"right\"][tidx, ni].T)\n", - " sel = ni>0\n", - " if e: S += e*(~sel).sum()\n", - " tidx, ni = tidx[sel], ni[sel]\n", - " # the size matters only at terminal nodes\n", - " size = trees[tidx, ni][\"size\"]\n", - " S += e*len(ni) + c_factor(size[size>1]).sum() \n", - " return S\n", - "\n", - "def score_samples_by_sample_pool(X, trees, nproc=6):\n", - " S = np.zeros(X.shape[0])\n", - " import multiprocessing as mp\n", - " with mp.Pool(nproc) as p:\n", - " iterable = (X[xi] for xi in range(X.shape[0]))\n", - " for i, si in enumerate(p.imap(worker, iterable, 100)):\n", - " S[i] = si\n", - " return S/len(trees)\n", - "\n", - "#%timeit score_samples_by_sample_pool(X, trees, 1) #1.96 s ± 50.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "#%timeit score_samples_by_sample_pool(X, trees, 6) # 484 ms ± 34.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "for i in range(1, 13):\n", - " print(i)\n", - " %timeit score_samples_by_sample_pool(X, trees, i) # 484 ms ± 34.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)" - ] - }, - { - "cell_type": "code", - "execution_count": 431, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " " - ] - } - ], - "source": [ - "%prun score_samples_by_sample(X, trees)" - ] - }, - { - "cell_type": "code", - "execution_count": 674, - "metadata": {}, - "outputs": [], - "source": [ - "w = np.random.choice([True, False], size=X.shape[0]), X.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 675, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "97.6 µs ± 60.5 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n" - ] - } - ], - "source": [ - "%timeit X[w], X[~w]" - ] - }, - { - "cell_type": "code", - "execution_count": 679, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "70.8 µs ± 44.6 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n" - ] - } - ], - "source": [ - "@jit\n", - "def split(x, w):\n", - " a = np.empty_like(x)\n", - " b = np.empty_like(x)\n", - " k = l = 0\n", - " for i in range(len(x)):\n", - " if w[i]: \n", - " a[k] = x[i]\n", - " k += 1\n", - " else:\n", - " b[l] = x[i]\n", - " l += 1\n", - " return a[:k], b[:l]\n", - "\n", - "%timeit split(X, w) #70.8 µs ± 44.6 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n", - "%timeit X[w], X[~w] #97.6 µs ± 60.5 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)" - ] } ], "metadata": { diff --git a/eif_new.py b/eif_new.py index 9275dd8..7df0efe 100644 --- a/eif_new.py +++ b/eif_new.py @@ -206,7 +206,7 @@ def score_samples(self, X): for e in range(1, self.limit): w = X[xi].dot(n[tidx, ni].T) < pdotn[tidx, ni] ni = update_nodes(ni, w, self.limit, e) - sel = sizes[tidx, ni]>1 + sel = sizes[tidx, ni]>0 S[xi] += score_false(e, sel) #e*(~sel).sum() tidx, ni = tidx[sel], ni[sel] # the size matters only at terminal nodes From cf50816f914c5524a544adc6b7fefa2d253c1b5c Mon Sep 17 00:00:00 2001 From: Leszek Date: Mon, 31 Aug 2020 17:49:48 +0200 Subject: [PATCH 6/7] performance matching c++ --- Notebooks/comparison_py_cxx.ipynb | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/Notebooks/comparison_py_cxx.ipynb b/Notebooks/comparison_py_cxx.ipynb index a9e0abb..6564c10 100644 --- a/Notebooks/comparison_py_cxx.ipynb +++ b/Notebooks/comparison_py_cxx.ipynb @@ -246,13 +246,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "%load_ext line_profiler\n", - "%lprun -f F3.populate_nodes F3.fit(X)" - ] + "source": [] } ], "metadata": { From 5e0bebdf1177fab11bd4b9bc69e2f9a5ba1de4c7 Mon Sep 17 00:00:00 2001 From: Leszek Date: Thu, 19 Nov 2020 15:49:46 +0100 Subject: [PATCH 7/7] solaris --- eif_new.py | 119 ++++++++++------------------------------------------- 1 file changed, 21 insertions(+), 98 deletions(-) mode change 100644 => 100755 eif_new.py diff --git a/eif_new.py b/eif_new.py old mode 100644 new mode 100755 index 7df0efe..4eed8c6 --- a/eif_new.py +++ b/eif_new.py @@ -3,12 +3,15 @@ This is the implementation of the Extended Isolation Forest anomaly detection algorithm. This extension, improves the consistency and reliability of the anomaly score produced by standard Isolation Forest represented by Liu et al. Our method allows for the slicing of the data to be done using hyperplanes with random slopes which results in improved score maps. The consistency and reliability of the algorithm is much improved using this extension. +This fork of https://github.com/sahandha/eif was rewritten from scratch. More information: +- https://github.com/sahandha/eif/issues/18 +- https://github.com/sahandha/eif/pull/24 """ -__author__ = 'Matias Carrasco Kind & Sahand Hariri (rewritten by Leszek Pryszcz)' +__author__ = 'Leszek Pryszcz (relying on method developed by Matias Carrasco Kind & Sahand Hariri)' import numpy as np import os -from version import __version__ +#from version import __version__ from numba import jit#, float32, int32 @jit @@ -114,7 +117,17 @@ def __init__(self, ntrees=200, sample=256, limit=None, exlevel=None, random_stat self.limit = limit self.ntrees = ntrees self.compute_paths = self.score_samples#_using_childs + self.cut_off_ = 0.5 + def fit_predict(self, X): + """Return array with outlier predictions: normal (False) and outlier (True).""" + self.fit(X) + return self.score_samples(X)>self.cut_off_ + + def predict(self, X): + """Return normal (0) and outlier (1) predictions""" + return self.score_samples(X)>self.cut_off_ + def fit(self, X): """Return iForest trained on data from X. @@ -143,7 +156,7 @@ def fit(self, X): if self.dim-self.exlevel-1: # shit, this may have replacements :/ self.choice = np.random.choice(self.dim, size=(self.ntrees, maxnodes, self.dim-self.exlevel-1))#.astype(dtype="f4") # populate trees - dtype = [("n", "%sf4"%self.dim), ("pdotn", "f4"), ("size", "u2")]#, ("left", "u2"), ("right", "u2")] + dtype = [("n", "%sf2"%self.dim), ("pdotn", "f2"), ("size", "u2")]#, ("left", "u2"), ("right", "u2")] self.trees = np.zeros((self.ntrees, maxnodes), dtype=dtype) for treei in range(self.ntrees): idx = np.random.choice(X.shape[0], self.sample, replace=False) @@ -175,10 +188,11 @@ def populate_nodes(self, X, treei, nodei=0, e=0): w = X.dot(n) < pdotn # here X.dot(n) uses BLAS so no need to optimise ;) # store current node self.trees[treei, nodei] = n, pdotn, len(X) - # add left & right node - a, b = split(X, w) # faster than X[~w], X[w] - self.populate_nodes(a, treei, nodei+1, e+1) - self.populate_nodes(b, treei, nodei+2**(self.limit-e), e+1) #2**(self.limit-e) + # split data from X in order to populate left & right nodes + left, right = split(X, w) # faster than X[~w], X[w] + # and add left & right node + self.populate_nodes(left, treei, nodei+1, e+1) + self.populate_nodes(right, treei, nodei+2**(self.limit-e), e+1) #2**(self.limit-e) def score_samples(self, X): """ @@ -215,94 +229,3 @@ def score_samples(self, X): # calculate anomaly scores S = np.power(2, -S / len(trees) / c_factor(self.sample)) return S - -''' - def populate_nodes(self, X, treei, nodei=0, e=0): - """Builds the tree recursively from a given node (e). - By default starts from root note (e=0) and make all trees symmetrical. - """ - # for terminal nodes store only the size of dataset at final split - if e==self.limit or len(X)<2: - self.trees["size"][treei, nodei] = len(X) - # and make sure all trees have nodes in identical positions/order in the array - if e0], ni[ni>0] - #if not len(ni): break - # store number trees for which the deepest node was reached - # and their sizes (size matters only at terminal nodes) - size = sizes[tidx, ni] - S[xi] += score_terminal(self.limit, ni, size) #self.limit*len(ni) + c_factor(size[size>1]).sum() - # divide by total number of trees in the fores - S *= 1. / len(trees) - # and calculate anomaly scores - S = 2.0**(-S / c_factor(self.sample)) - return S - - -@jit -def where(w, a, b): - """Return np.where(w, a, b)""" - return np.where(w, a, b) - -@jit -def score_empty(e, ni): - """Return e*(ni==0).sum()""" - return e*(ni==0).sum() -'''