Détection des anomalies des séries temporelles

L’approche est assez simple. Les instances de données qui ne font pas partie des clusters définis peuvent potentiellement être marquées comme anomalies.

Par souci de visualisation, nous utiliserons un ensemble de données différent qui correspond à une série temporelle multivariée avec une ou plusieurs variables temporelles. L’ensemble de données sera un sous-ensemble de celui trouvé ici (les colonnes/caractéristiques sont les mêmes).

Description de l’ensemble de données : Les données contiennent des informations sur les achats et les achats ainsi que des informations sur la compétitivité des prix.

Maintenant, pour traiter les k-moyennes, nous devons d’abord connaître le nombre de clusters que nous allons traiter. La méthode Elbow fonctionne assez efficacement pour cela.

La méthode Elbow est un graphique du nombre de clusters par rapport à la variance expliquée/objectif/score

Pour implémenter cela, nous utiliserons l’implémentation de K-means par scikit-learn.

data = df[['price_usd', 'srch_booking_window', 'srch_saturday_night_bool']]
n_cluster = range(1, 20)
kmeans = [KMeans(n_clusters=i).fit(data) for i in n_cluster]
scores = [kmeans[i].score(data) for i in range(len(kmeans))]
fig, ax = plt.subplots(figsize=(10,6))
ax.plot(n_cluster, scores)
plt.xlabel('Number of Clusters')
plt.ylabel('Score')
plt.title('Elbow Curve')
plt.show();

À partir de la courbe coudée ci-dessus, nous voyons que le graphique se stabilise après 10 clusters, ce qui implique que l’ajout de clusters supplémentaires n’explique pas beaucoup plus la variance de notre variable pertinente ; dans ce cas, price_usd.

Nous définissons n_clusters = 10 et, lors de la génération de la sortie k-means, utilisons les données pour tracer les clusters 3D.

Il nous faut maintenant connaître le nombre de composants (fonctionnalités) à conserver.

data = df[['price_usd', 'srch_booking_window', 'srch_saturday_night_bool']]
X = data.values
X_std = StandardScaler().fit_transform(X)
#Calculating Eigenvecors and eigenvalues of Covariance matrix
mean_vec = np.mean(X_std, axis=0)
cov_mat = np.cov(X_std.T)
eig_vals, eig_vecs = np.linalg.eig(cov_mat)
# Create a list of (eigenvalue, eigenvector) tuples
eig_pairs = [ (np.abs(eig_vals[i]),eig_vecs[:,i]) for i in range(len(eig_vals))]
eig_pairs.sort(key = lambda x: x[0], reverse= True)
# Calculation of Explained Variance from the eigenvalues
tot = sum(eig_vals)
var_exp = [(i/tot)*100 for i in sorted(eig_vals, reverse=True)] # Individual explained variance
cum_var_exp = np.cumsum(var_exp) # Cumulative explained variance
plt.figure(figsize=(10, 5))
plt.bar(range(len(var_exp)), var_exp, alpha=0.3, align='center', label='individual explained variance', color = 'y')
plt.step(range(len(cum_var_exp)), cum_var_exp, where='mid',label='cumulative explained variance')
plt.ylabel('Explained variance ratio')
plt.xlabel('Principal components')
plt.legend(loc='best')
plt.show();

On voit que la première composante explique près de 50 % de la variance. La deuxième composante explique plus de 30 %. Cependant, notez que presque aucun des composants n’est vraiment négligeable. Les 2 premiers composants contiennent plus de 80 % des informations. Nous définirons donc n_components=2.

L’hypothèse sous-jacente à la détection des anomalies basée sur le clustering est que si nous regroupons les données, les données normales appartiendront à des clusters tandis que les anomalies n’appartiendront à aucun cluster ou appartiendront à de petits clusters.

Nous utilisons les étapes suivantes pour rechercher et visualiser les anomalies :

• Calculez la distance entre chaque point et son centre de gravité le plus proche. Les plus grandes distances sont considérées comme des anomalies.
• Nous utilisons outliers_fraction pour fournir des informations à l’algorithme sur la proportion de valeurs aberrantes présentes dans notre ensemble de données, de la même manière que l’algorithme IsolationForest. Il s’agit en grande partie d’un hyperparamètre qui nécessite un hit/essai ou une recherche sur grille pour être correctement défini – comme chiffre de départ, estimons, outliers_fraction=0,1
• Calculez number_of_outliers à l’aide de outliers_fraction.
• Définissez le seuil comme distance minimale de ces valeurs aberrantes.
• Le résultat de l’anomalie d’anomalie1 contient la méthode ci-dessus Cluster (0 : normal, 1 : anomalie).
• Visualisez les anomalies avec la vue cluster.
• Visualisez les anomalies avec la vue Time Series.

# return Series of distance between each point and its distance with the closest centroid
def getDistanceByPoint(data, model):
   distance = pd.Series()
   for i in range(0,len(data)):
       Xa = np.array(data.loc[i])
       Xb = model.cluster_centers_[model.labels_[i]-1]
       distance.at[i]=np.linalg.norm(Xa-Xb)
   return distance
outliers_fraction = 0.1
# get the distance between each point and its nearest centroid. The biggest distances are considered as anomaly
distance = getDistanceByPoint(data, kmeans[9])
number_of_outliers = int(outliers_fraction*len(distance))
threshold = distance.nlargest(number_of_outliers).min()
# anomaly1 contain the anomaly result of the above method Cluster (0:normal, 1:anomaly)
df['anomaly1'] = (distance >= threshold).astype(int)
fig, ax = plt.subplots(figsize=(10,6))
colors = {0:'blue', 1:'red'}
ax.scatter(df['principal_feature1'], df['principal_feature2'], c=df["anomaly1"].apply(lambda x: colors[x]))
plt.xlabel('principal feature1')
plt.ylabel('principal feature2')
plt.show();

Désormais, afin de voir les anomalies par rapport aux fonctionnalités du monde réel, nous traitons la trame de données que nous avons créée à l’étape précédente.

df = df.sort_values('date_time')
fig, ax = plt.subplots(figsize=(10,6))
a = df.loc[df['anomaly1'] == 1, ['date_time', 'price_usd']] #anomaly
ax.plot(pd.to_datetime(df['date_time']), df['price_usd'], color='k',label='Normal')
ax.scatter(pd.to_datetime(a['date_time']),a['price_usd'], color='red', label='Anomaly')
ax.xaxis_date()
plt.xlabel('Date Time')
plt.ylabel('price in USD')
plt.legend()
fig.autofmt_xdate()
plt.show()

Cette méthode est capable d’encapsuler assez bien les pics, avec quelques ratés bien sûr. Une partie du problème peut être due au fait que outlier_fraction n’a pas joué avec de nombreuses valeurs.

Le plus grand avantage de cette technique est similaire à d’autres techniques non supervisées, à savoir que vous pouvez introduire autant de variables ou de fonctionnalités aléatoires que vous le souhaitez pour créer des modèles plus sophistiqués.

La faiblesse est qu’un nombre croissant de fonctionnalités peuvent commencer à avoir un impact assez rapidement sur vos performances de calcul. En plus de cela, il y a davantage d’hyper-paramètres à régler et à corriger, il y a donc toujours un risque de variation élevée des performances du modèle.