# Introduction: Anomaly Detection

From

Anomaly detection is a technique used to identify unusual patterns that do not conform to expected behavior, called outliers. It has many applications in business, from intrusion detection (identifying strange patterns in network traffic that could signal a hack) to system health monitoring (spotting a malignant tumor in an MRI scan), and from fraud detection in credit card transactions to fault detection in operating environments.

In this jupyter notebook we are going to take the credit card fraud detection as the case study for understanding this concept in detail.

## What Are Anomalies?

In data mining, anomaly detection (also outlier detection) is the identification of rare items, events or observations which raise suspicions by differing significantly from the majority of the data. Anomalies can be broadly categorized as:

Point anomalies: A single instance of data is anomalous if it’s too far off from the rest. Business use case: Detecting credit card fraud based on “amount spent.”

Contextual anomalies: The abnormality is context specific. This type of anomaly is common in time-series data. Business use case: Spending \$100 on food every day during the holiday season is normal, but may be odd otherwise.

Collective anomalies: A set of data instances collectively helps in detecting anomalies. Business use case: Someone is trying to copy data form a remote machine to a local host unexpectedly, an anomaly that would be flagged as a potential cyber attack.

Anomaly detection is similar to — but not entirely the same as — noise removal and novelty detection.

Novelty detection is concerned with identifying an unobserved pattern in new observations not included in training data like a sudden interest in a new channel on YouTube during Christmas, for instance.

Noise removal (NR) is the process of removing noise from an otherwise meaningful signal.

## 1. Anomaly Detection Techniques

#### Simple Statistical Methods

The simplest approach to identifying irregularities in data is to flag the data points that deviate from common statistical properties of a distribution, including mean, median, mode, and quantiles. Let’s say the definition of an anomalous data point is one that deviates by a certain standard deviation from the mean. Traversing mean over time-series data isn’t exactly trivial, as it’s not static. You would need a rolling window to compute the average across the data points. Technically, this is called a rolling average or a moving average, and it’s intended to smooth short-term fluctuations and highlight long-term ones. Mathematically, an n-period simple moving average can also be defined as a “low pass filter.”

#### Challenges with Simple Statistical Methods

The low pass filter allows you to identify anomalies in simple use cases, but there are certain situations where this technique won’t work. Here are a few:

The data contains noise which might be similar to abnormal behavior, because the boundary between normal and abnormal behavior is often not precise.

The definition of abnormal or normal may frequently change, as malicious adversaries constantly adapt themselves. Therefore, the threshold based on moving average may not always apply.

The pattern is based on seasonality. This involves more sophisticated methods, such as decomposing the data into multiple trends in order to identify the change in seasonality.

## 2. Machine Learning-Based Approaches

Below is a brief overview of popular machine learning-based techniques for anomaly detection.

#### a.Density-Based Anomaly Detection

Density-based anomaly detection is based on the k-nearest neighbors algorithm.

Assumption: Normal data points occur around a dense neighborhood and abnormalities are far away.

The nearest set of data points are evaluated using a score, which could be Eucledian distance or a similar measure dependent on the type of the data (categorical or numerical). They could be broadly classified into two algorithms:

K-nearest neighbor: k-NN is a simple, non-parametric lazy learning technique used to classify data based on similarities in distance metrics such as Eucledian, Manhattan, Minkowski, or Hamming distance.

Relative density of data: This is better known as local outlier factor (LOF). This concept is based on a distance metric called reachability distance.

#### b.Clustering-Based Anomaly Detection

Clustering is one of the most popular concepts in the domain of unsupervised learning.

Assumption: Data points that are similar tend to belong to similar groups or clusters, as determined by their distance from local centroids.

K-means is a widely used clustering algorithm. It creates ‘k’ similar clusters of data points. Data instances that fall outside of these groups could potentially be marked as anomalies.

#### c.Support Vector Machine-Based Anomaly Detection

A support vector machine is another effective technique for detecting anomalies.

A SVM is typically associated with supervised learning, but there are extensions (OneClassCVM, for instance) that can be used to identify anomalies as an unsupervised problems (in which training data are not labeled).

The algorithm learns a soft boundary in order to cluster the normal data instances using the training set, and then, using the testing instance, it tunes itself to identify the abnormalities that fall outside the learned region.

Depending on the use case, the output of an anomaly detector could be numeric scalar values for filtering on domain-specific thresholds or textual labels (such as binary/multi labels).

In this jupyter notebook we are going to take the credit card fraud detection as the case study for understanding this concept in detail using the following Anomaly Detection Techniques namely

## Problem Statement:

The Credit Card Fraud Detection Problem includes modeling past credit card transactions with the knowledge of the ones that turned out to be fraud. This model is then used to identify whether a new transaction is fraudulent or not. Our aim here is to detect 100% of the fraudulent transactions while minimizing the incorrect fraud classifications.

#### DataSet :

The dataset that is used for credit card fraud detection is derived from the following Kaggle URL :https://www.kaggle.com/mlg-ulb/creditcardfraud

#### Observations

The data set is highly skewed, consisting of 492 frauds in a total of 284,807 observations. This resulted in only 0.172% fraud cases. This skewed set is justified by the low number of fraudulent transactions.

The dataset consists of numerical values from the 28 ‘Principal Component Analysis (PCA)’ transformed features, namely V1 to V28. Furthermore, there is no metadata about the original features provided, so pre-analysis or feature study could not be done.

The ‘Time’ and ‘Amount’ features are not transformed data.

There is no missing value in the dataset.

## Preprocessing

### Import Libraries

Code

``````---------------------------------------------------------------------------
ImportError                               Traceback (most recent call last)
&lt;ipython-input-1-efc2bb327014&gt; in &lt;module&gt;
<strong>     13</strong> RANDOM_SEED = 42
<strong>     14</strong> LABELS = ["Normal", "Fraud"]
---&gt; 15 import plotly.plotly as py
<strong>     16</strong> import plotly.graph_objs as go
<strong>     17</strong> import plotly

/opt/conda/lib/python3.6/site-packages/plotly/plotly/__init__.py in &lt;module&gt;
<strong>      2</strong> from _plotly_future_ import _chart_studio_error
<strong>      3</strong>
----&gt; 4 _chart_studio_error("plotly")

/opt/conda/lib/python3.6/site-packages/_plotly_future_/__init__.py in _chart_studio_error(submodule)
<strong>     48</strong> """.format(
---&gt; 49             submodule=submodule
<strong>     50</strong>         )
<strong>     51</strong>     )

ImportError:
The plotly.plotly module is deprecated,
please install the chart-studio package and use the
``````

Code

``````Index(['Time', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6', 'V7', 'V8', 'V9', 'V10',
'V11', 'V12', 'V13', 'V14', 'V15', 'V16', 'V17', 'V18', 'V19', 'V20',
'V21', 'V22', 'V23', 'V24', 'V25', 'V26', 'V27', 'V28', 'Amount',
'Class'],
dtype='object')
``````

CodeOut[3]:

`(28481, 31)`

CodeOut[4]:

8 rows × 31 columns

## Exploratory Data Analysis

CodeOut[5]:

`(284807, 31)`

Let us now check the missing values in the datasetCodeOut[6]:

`False`

CodeOut[7]:

5 rows × 31 columnsCode

Determine the number of fraud and valid transactions in the entire dataset.CodeCodeOut[10]:

`(492, 31)`

CodeOut[11]:

`(284315, 31)`

How different are the amount of money used in different transaction classes?CodeOut[12]:

``````count     492.000000
mean      122.211321
std       256.683288
min         0.000000
25%         1.000000
50%         9.250000
75%       105.890000
max      2125.870000
Name: Amount, dtype: float64``````

CodeOut[13]:

``````count    284315.000000
mean         88.291022
std         250.105092
min           0.000000
25%           5.650000
50%          22.000000
75%          77.050000
max       25691.160000
Name: Amount, dtype: float64``````

Let’s have a more graphical representation of the dataCode

Do fraudulent transactions occur more often during certain time frame ? Let us find out with a visual representation.Code

Code

``````---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
&lt;ipython-input-16-33f4382ea43d&gt; in &lt;module&gt;
----&gt; 1 init_notebook_mode(connected=True)
<strong>      2</strong> plotly.offline.init_notebook_mode(connected=True)

NameError: name 'init_notebook_mode' is not defined``````

Code

``````---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
&lt;ipython-input-17-a6e929903159&gt; in &lt;module&gt;
<strong>      1</strong> # Create a trace
<strong>      2</strong>
----&gt; 3 trace = go.Scatter(
<strong>      4</strong>     x = Fraud.Time,
<strong>      5</strong>     y = Fraud.Amount,

NameError: name 'go' is not defined``````

Code

``````---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
&lt;ipython-input-18-8e74bdcef5c4&gt; in &lt;module&gt;
----&gt; 1 plotly.offline.iplot({
<strong>      2</strong>     "data": data
<strong>      3</strong> })

NameError: name 'plotly' is not defined``````

Doesn’t seem like the time of transaction really matters here as per above observation. Now let us take a sample of the dataset for out modelling and predictionCodeOut[19]:

`(28481, 31)`

Plot histogram of each parameterCode

Determine the number of fraud and valid transactions in the dataset.Code

Now let us print the outlier fraction and no of Fraud and Valid Transaction casesCode

```0.0017234102419808666
Fraud Cases : 49
Valid Cases : 28432
```

Correlation MatrixCode

The above correlation matrix shows that none of the V1 to V28 PCA components have any correlation to each other however if we observe Class has some form positive and negative correlations with the V components but has no correlation with Time and Amount.

Get all the columns from the dataframeCode

```(28481, 30)
(28481,)
```

## Model Prediction

Now it is time to start building the model .The types of algorithms we are going to use to try to do anomaly detection on this dataset are as follows

#### 1. Isolation Forest Algorithm:

One of the newest techniques to detect anomalies is called Isolation Forests. The algorithm is based on the fact that anomalies are data points that are few and different. As a result of these properties, anomalies are susceptible to a mechanism called isolation.

This method is highly useful and is fundamentally different from all existing methods. It introduces the use of isolation as a more effective and efficient means to detect anomalies than the commonly used basic distance and density measures. Moreover, this method is an algorithm with a low linear time complexity and a small memory requirement. It builds a good performing model with a small number of trees using small sub-samples of fixed size, regardless of the size of a data set.

Typical machine learning methods tend to work better when the patterns they try to learn are balanced, meaning the same amount of good and bad behaviors are present in the dataset.

#### How Isolation Forests Work

The Isolation Forest algorithm isolates observations by randomly selecting a feature and then randomly selecting a split value between the maximum and minimum values of the selected feature. The logic argument goes: isolating anomaly observations is easier because only a few conditions are needed to separate those cases from the normal observations. On the other hand, isolating normal observations require more conditions. Therefore, an anomaly score can be calculated as the number of conditions required to separate a given observation.

The way that the algorithm constructs the separation is by first creating isolation trees, or random decision trees. Then, the score is calculated as the path length to isolate the observation.

#### 2. Local Outlier Factor(LOF) Algorithm

The LOF algorithm is an unsupervised outlier detection method which computes the local density deviation of a given data point with respect to its neighbors. It considers as outlier samples that have a substantially lower density than their neighbors.

The number of neighbors considered, (parameter n_neighbors) is typically chosen 1) greater than the minimum number of objects a cluster has to contain, so that other objects can be local outliers relative to this cluster, and 2) smaller than the maximum number of close by objects that can potentially be local outliers. In practice, such informations are generally not available, and taking n_neighbors=20 appears to work well in general.

Define the outlier detection methodsCode

Fit the modelCode

``````/opt/conda/lib/python3.6/site-packages/sklearn/ensemble/iforest.py:247: FutureWarning:

behaviour="old" is deprecated and will be removed in version 0.22. Please use behaviour="new", which makes the decision_function change to match other anomaly detection algorithm API.

/opt/conda/lib/python3.6/site-packages/sklearn/ensemble/iforest.py:415: DeprecationWarning:

threshold_ attribute is deprecated in 0.20 and will be removed in 0.22.

``````
``````Isolation Forest: 73
Accuracy Score :
0.9974368877497279
Classification Report :
precision    recall  f1-score   support

0       1.00      1.00      1.00     28432
1       0.26      0.27      0.26        49

accuracy                           1.00     28481
macro avg       0.63      0.63      0.63     28481
weighted avg       1.00      1.00      1.00     28481

Local Outlier Factor: 97
Accuracy Score :
0.9965942207085425
Classification Report :
precision    recall  f1-score   support

0       1.00      1.00      1.00     28432
1       0.02      0.02      0.02        49

accuracy                           1.00     28481
macro avg       0.51      0.51      0.51     28481
weighted avg       1.00      1.00      1.00     28481

``````
```/opt/conda/lib/python3.6/site-packages/sklearn/svm/classes.py:1194: DeprecationWarning:

The random_state parameter is deprecated and will be removed in version 0.22.

```
```Support Vector Machine: 8516
Accuracy Score :
0.7009936448860644
Classification Report :
precision    recall  f1-score   support

0       1.00      0.70      0.82     28432
1       0.00      0.37      0.00        49

accuracy                           0.70     28481
macro avg       0.50      0.53      0.41     28481
weighted avg       1.00      0.70      0.82     28481

```

#### Observations :

Isolation Forest detected 73 errors versus Local Outlier Factor detecting 97 errors vs. SVM detecting 8516 errors

Isolation Forest has a 99.74% more accurate than LOF of 99.65% and SVM of 70.09

When comparing error precision & recall for 3 models , the Isolation Forest performed much better than the LOF as we can see that the detection of fraud cases is around 27 % versus LOF detection rate of just 2 % and SVM of 0%.

So overall Isolation Forest Method performed much better in determining the fraud cases which is around 30%.

We can also improve on this accuracy by increasing the sample size or use deep learning algorithms however at the cost of computational expense.We can also use complex anomaly detection models to get better accuracy in determining more fraudulent cases

Now let us look at one particular Deep Learning Algorithm called Autoencoders

## Autoencoders

An autoencoder is a type of artificial neural network used to learn efficient data codings in an unsupervised manner.

The aim of an autoencoder is to learn a representation (encoding) for a set of data, typically for the purpose of dimensionality reduction.

An autoencoder learns to compress data from the input layer into a short code, and then uncompress that code into something that closely matches the original data. This forces the autoencoder to engage in dimensionality reduction, for example by learning how to ignore noise. Some architectures use stacked sparse autoencoder layers for image recognition. The first autoencoder might learn to encode easy features like corners, the second to analyze the first layer’s output and then encode less local features like the tip of a nose, the third might encode a whole nose, etc., until the final autoencoder encodes the whole image into a code that matches (for example) the concept of “cat”.An alternative use is as a generative model: for example, if a system is manually fed the codes it has learned for “cat” and “flying”, it may attempt to generate an image of a flying cat, even if it has never seen a flying cat before.

The simplest form of an autoencoder is a feedforward, non-recurrent neural network very similar to the many single layer perceptrons which makes a multilayer perceptron (MLP) – having an input layer, an output layer and one or more hidden layers connecting them – but with the output layer having the same number of nodes as the input layer, and with the purpose of reconstructing its own inputs (instead of predicting the target value Y given inputs X). Therefore, autoencoders are unsupervised learning models.