Quelles sont les techniques pour détecter les anomalies

Détection d’une anomalie est l’identification d’éléments, d’événements ou d’observations rares qui soulèvent des soupçons en différant considérablement de la majorité des données. En règle générale, les éléments anormaux se traduiront par une sorte de problème tel que la fraude par carte de crédit, l’intrusion dans le réseau, le diagnostic médical, le moniteur de santé du système.

La détection des anomalies fonctionne sur deux prémisses de base

• Les anomalies ne se produisent que très rarement dans les données.
• Leurs caractéristiques diffèrent considérablement des instances normales.

L’approche la plus simple pour identifier les irrégularités dans les données consiste à signaler les points de données qui s’écartent des propriétés statistiques de distribution communes, notamment la moyenne, la médiane, le mode et les quartiles.

L’un des moyens les plus populaires est le Gamme interquartile (IQR). L’IQR est un concept statistique utilisé pour mesurer la dispersion statistique et la variabilité des données en divisant l’ensemble de données en quartiles.

En termes simples, tout ensemble de données ou tout ensemble d’observations est divisé en quatre intervalles définis en fonction des valeurs des données et de leur comparaison avec l’ensemble de données. Un quartile est ce qui divise les données en trois points et quatre intervalles.

Source de l’image: Wikipedia

L’intervalle interquartile (IQR) est important car il est utilisé pour définir les valeurs aberrantes. C’est la différence entre le troisième quartile et le premier quartile (IQR = Q3 -Q1). Les valeurs aberrantes, dans ce cas, sont définies comme les observations inférieures (Q1 – 1,5x IQR) ou supérieures (Q3 + 1,5x IQR)

Source de l’image: Wikipedia

la mise en oeuvre

np.percentile est une fonctionnalité cuite en Python

q75, q25 = np.percentile(x, [75 ,25])
iqr = q75 - q25

Désavantages

La technique IQR ne fonctionne pas dans les scénarios suivants

1. Le modèle est basé sur la saisonnalité. Cela implique des méthodes plus sophistiquées, telles que la décomposition des données en plusieurs tendances pour identifier le changement de saisonnalité.

2. La définition d’anormal ou de normal peut changer fréquemment, car des adversaires malveillants s’adaptent constamment

Le clustering est l’un des concepts les plus populaires dans le domaine de l’apprentissage non supervisé. La prémisse sous-jacente est que les points de données similaires appartiennent généralement à des groupes ou grappes similaires, déterminés par leur distance des centroïdes locaux.

K-means est un algorithme de clustering largement utilisé. Il crée «k» des grappes similaires de points de données. Les instances de données qui ne relèvent pas de ces groupes peuvent potentiellement être marquées comme des anomalies. D’autres algorithmes de clustering tels que le clustering hiérarchique et l’analyse de base de données peuvent également être utilisés pour détecter les valeurs aberrantes.

Le fonctionnement de l’algorithme K-means est le suivant:

1. Spécifiez le nombre de clusters K.
2. Initialiser les centroïdes en mélangeant d’abord l’ensemble de données, puis en sélectionnant au hasard K points de données pour les centroïdes sans remplacement.
3. Calculez les distances entre les centroïdes et les points de données.
4. Continuez à itérer jusqu’à ce qu’il n’y ait aucun changement aux centroïdes. c’est-à-dire que l’attribution des points de données aux clusters ne change pas.

la mise en oeuvre

1. Initialiser des centroïdes aléatoires

Vous commencez le processus en prenant trois (comme nous avons décidé que K est 3) des points aléatoires (sous la forme de (x, y)). Ces points sont appelés centroïdes qui est juste un nom de fantaisie pour désigner centres. Nommons ces trois points – C1, C2, et C3 afin que vous puissiez les référer plus tard.

2. Calculer les distances entre les centroïdes et les points de données

Ensuite, vous mesurez les distances des points de données à partir de ces trois points choisis au hasard. Un choix très populaire de fonction de mesure de distance, dans ce cas, est le Distance euclidienne.

En bref, s’il y a n points sur un espace 2D (tout comme la figure ci-dessus) et que leurs coordonnées sont désignées par (x_i, y_i), alors la distance euclidienne entre deux points quelconques ((x1, y1) et(x2, y2)) sur cet espace est donné par:

Supposons que les coordonnées de C1, C2 et C3 soient – (-1, 4), (-0,2, 1,5), et (2, 2,5) respectivement. Écrivons maintenant quelques lignes de code Python qui calculeront les distances euclidiennes entre les points de données et ces centroïdes choisis au hasard. Nous commençons par initialiser les centroïdes.

# Initialize the centroids
c1 = (-1, 4)
c2 = (-0.2, 1.5)
c3 = (2, 2.5)

Ensuite, nous écrivons une petite fonction d’aide pour calculer les distances euclidiennes entre les points de données et les centroïdes.

# A helper function to calculate the Euclidean distance between the data points and the centroidsdef calculate_distance(centroid, X, Y):
distances = []
# Unpack the x and y coordinates of the centroid
c_x, c_y = centroid

# Iterate over the data points and calculate the distance using the           # given formula
for x, y in list(zip(X, Y)):
root_diff_x = (x - c_x) ** 2
root_diff_y = (y - c_y) ** 2
distance = np.sqrt(root_diff_x + root_diff_y)
distances.append(distance)
return distances

Nous pouvons maintenant appliquer cette fonction aux points de données et affecter les résultats en conséquence.

# Calculate the distance and assign them to the DataFrame accordingly
data['C1_Distance'] = calculate_distance(c1, data.X_value, data.Y_value)
data['C2_Distance'] = calculate_distance(c2, data.X_value, data.Y_value)
data['C3_Distance'] = calculate_distance(c3, data.X_value, data.Y_value)# Preview the data
print(data.head())

3. Comparer, attribuer, signifier et répéter

Il s’agit fondamentalement de la dernière étape de l’algorithme de clustering K-Means. Une fois que vous avez les distances entre les points de données et les centroïdes, vous comparez les distances et prenez la les plus petits. Le centroïde auquel la distance pour un point de données particulier est le plus petit, ce centroïde est affecté en tant que cluster pour ce point de données particulier.

Faisons-le par programmation.

# Get the minimum distance centroids
data['Cluster'] = data[['C1_Distance', 'C2_Distance', 'C3_Distance']].apply(np.argmin, axis =1)
# Map the centroids accordingly and rename them
data['Cluster'] = data['Cluster'].map({'C1_Distance': 'C1', 'C2_Distance': 'C2', 'C3_Distance': 'C3'})
# Get a preview of the data
print(data.head(10))

Vient maintenant la partie la plus intéressante de mise à jour des centroïdes en déterminant le signifier valeurs des coordonnées des points de données (qui devraient maintenant appartenir à un centroïde). D’où le nom K-Means. Voici à quoi ressemble le calcul moyen:

Les lignes de code suivantes le font pour vous:

# Calculate the coordinates of the new centroid from cluster 1
x_new_centroid1 = data[data['Cluster']=='C1']['X_value'].mean()
y_new_centroid1 = data[data['Cluster']=='C1']['Y_value'].mean()# Calculate the coordinates of the new centroid from cluster 2
x_new_centroid2 = data[data['Cluster']=='C3']['X_value'].mean()
y_new_centroid2 = data[data['Cluster']=='C3']['Y_value'].mean()# Print the coordinates of the new centroids
print('Centroid 1 ({}, {})'.format(x_new_centroid1, y_new_centroid1))
print('Centroid 2 ({}, {})'.format(x_new_centroid2, y_new_centroid2))

Ce processus est répété jusqu’à ce que les coordonnées des centroïdes ne soient plus mises à jour.

Désavantages

L’algorithme K-means est populaire et utilisé dans une variété d’applications telles que la compression d’image, la classification de documents. L’objectif de la moyenne K est de regrouper les points de données en sous-groupes distincts qui ne se chevauchent pas. Il fait un très bon travail lorsque les grappes ont une sorte de forme sphérique. Cependant, il souffre car les formes géométriques des grappes s’écartent des formes sphériques. De plus, il n’apprend pas non plus le nombre de clusters à partir des données et nécessite qu’il soit prédéfini.

La forêt d’isolement est un algorithme d’apprentissage non supervisé qui appartient à la famille des arbres de décision d’ensemble. Cette approche est différente de toutes les méthodes précédentes. Tous les précédents tentaient de trouver la région normale des données, puis identifient tout ce qui se trouve en dehors de cette région définie comme étant une valeur aberrante ou anormale. Cette méthode fonctionne différemment. Il isole explicitement les anomalies au lieu de profiler et de construire des points et des régions normaux en attribuant un score à chaque point de données. Il tire parti du fait que les anomalies sont les points de données minoritaires et qu’elles ont des valeurs d’attribut très différentes de celles des instances normales.

Isolation: les forêts «isolent» les observations en sélectionnant au hasard une entité, puis en sélectionnant au hasard une valeur divisée entre les valeurs maximale et minimale de l’entité sélectionnée.

Étant donné que le partitionnement récursif peut être représenté par une structure arborescente, le nombre de séparations nécessaires pour isoler un échantillon est équivalent à la longueur de chemin du nœud racine au nœud de terminaison.

Cette longueur de trajet moyenne sur une forêt de tels arbres aléatoires est une mesure de la normalité et de notre fonction de décision.

Le partitionnement aléatoire produit des trajets plus courts notables pour les anomalies. Par conséquent, lorsqu’une forêt d’arbres aléatoires produit collectivement des longueurs de trajet plus courtes pour des échantillons particuliers, il est fort probable qu’il s’agisse d’anomalies.

Cet algorithme fonctionne très bien avec des ensembles de données de dimension très élevée et il s’est avéré être un moyen très efficace de détecter des anomalies.

Cette papier couvre tous les détails sur le fonctionnement de la forêt d’isolement.

la mise en oeuvre

import numpy as np
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForestrng = np.random.RandomState(42)# Generate train data
X = 0.3 * rng.randn(100, 2)
X_train = np.r_[X + 2, X - 2]
# Generate some regular novel observations
X = 0.3 * rng.randn(20, 2)
X_test = np.r_[X + 2, X - 2]
# Generate some abnormal novel observations
X_outliers = rng.uniform(low=-4, high=4, size=(20, 2))# fit the model
clf = IsolationForest(max_samples=100, random_state=rng)
clf.fit(X_train)
y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)# plot the line, the samples, and the nearest vectors to the plane
xx, yy = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)plt.title("IsolationForest")
plt.contourf(xx, yy, Z, cmap=plt.cm.Blues_r)b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c='white',
s=20, edgecolor='k')
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c='green',
s=20, edgecolor='k')
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c='red',
s=20, edgecolor='k')
plt.axis('tight')
plt.xlim((-5, 5))
plt.ylim((-5, 5))
plt.legend([b1, b2, c],
["training observations",
"new regular observations", "new abnormal observations"],
loc="upper left")
plt.show()

Source: scikit-learn.org

Cet article donne un aperçu des différentes techniques pour détecter les anomalies dans les données. Cela va de l’utilisation de méthodes statistiques simples comme l’écart-type aux algorithmes d’apprentissage non supervisés comme Isolation Forest. Chaque méthode a ses avantages et ses inconvénients. Par exemple. L’interquartile (IQR) ne fonctionne pas pour les modèles saisonniers. Il fait un très bon travail lorsque les grappes ont une sorte de forme sphérique. Isolation Forest propose une approche à contre-courant pour détecter les anomalies. Il tire parti du fait que les anomalies sont les points de données minoritaires et qu’elles ont des valeurs d’attribut très différentes de celles des instances normales. Pour être un bon praticien, il est bon de connaître les hypothèses sous-jacentes aux algorithmes / méthodes afin d’avoir une assez bonne idée des forces et des faiblesses de chaque méthode. Cela vous aidera à décider quand utiliser chaque méthode et dans quelles circonstances.