Wiki du LAMA (UMR 5127) - Contributions [fr]

Tutoriel utilisation algorithme Isolation Forest

2022-05-29T18:44:35Z

Mdesmet :

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre base de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toutes les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
données suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toutes les variable"

==3 Recherche anomalie pour toutes les variables¶==

Dans cette section nous prenons en compte toutes les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche d'anomalies pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variable, par exemple ne
prendre en compte que la variable de l'âge dans une certaine population, il faut utiliser le code
suivant.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ''

nom_variable =''

<nowiki># Reste du code à ne pas modifier</nowiki>

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

<nowiki>model.fit(df[[nom_variable]])</nowiki>

<nowiki>model.predict(df[[nom_variable]])</nowiki>

<nowiki>df['scores']=model.decision_function(df[[nom_variable]])</nowiki>

<nowiki>
df['anomaly']=model.predict(df[[nom_variable]])</nowiki>

anomaly=df.loc[df['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous afficher les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créé un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toutes ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres dont la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivant vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux en opération c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande base de données nous
n’utilisons pas forcément tous les éléments de la base de données pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil de normalité sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations (splits) parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme en indiquant la proportions de l'echantillon à isoler pour arrêter un arbre.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.

Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateurs dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

== Utilisation du model==

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiant pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''

La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)
''

Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toutes les
lignes correspondant à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''<nowiki># valeur à entrer</nowiki>

var1 = '’

var2 = ''

<nowiki># Code à ne pas modifier</nowiki>

pred_scores = -1*model.score_samples(df)

plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')

plt.colorbar(label='Simplified Anomaly Score')

show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique.
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-29T18:22:17Z

Mdesmet :

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelques mots l’algorithme Isolation Forest est un algorithme non supervisé de machine learning. Il est conçu pour détecter des valeurs anormales au sein d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voitures, ordinateurs, montres connectées…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des premières étapes après la collecte des données est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être dû à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire à cause de cause extérieurs (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Dataset : Jeu de données en français est un ensemble de données associées, la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart (distance par rapport) à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps.

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isolé ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre. Ici la population est petite il est donc facile de compléter l'arbre jusqu'à ce que tous les éléments soient isolés mais lorsque on traite des populations bien plus imposantes il n'est pas nécessaire de compléter les arbres, on s'arrête usuellement lorsque quelques individus ont étés isolés.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « forêt » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbres nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui ont étés réalisés pour isoler l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler, ce qui est faaible. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler, ce qui est plus élevé. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la forêt nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’élément relevé dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de données d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribuer un score d’anomalie grâce à l’analyse de la foret créée à l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

[[Fichier:Tutoriel.pdf]]

Ou la page wiki suivante :

[[Tutoriel utilisation algorithme Isolation Forest]]

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prises en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalies est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de splits nécessaires pour l’isoler.

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions dû au fait que les points soient clairsemés dans l’espace de dimension élevé.

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Tutoriel utilisation algorithme Isolation Forest

2022-05-27T17:30:36Z

Mdesmet :

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ''

nom_variable =''

<nowiki># Reste du code à ne pas modifier</nowiki>

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

<nowiki>model.fit(df[[nom_variable]])</nowiki>

<nowiki>model.predict(df[[nom_variable]])</nowiki>

<nowiki>df['scores']=model.decision_function(df[[nom_variable]])</nowiki>

<nowiki>
df['anomaly']=model.predict(df[[nom_variable]])</nowiki>

anomaly=df.loc[df['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

== Utilisation du model==

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''

La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)
''

Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''<nowiki># valeur à entrer</nowiki>

var1 = '’

var2 = ''

<nowiki># Code à ne pas modifier</nowiki>

pred_scores = -1*model.score_samples(df)

plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')

plt.colorbar(label='Simplified Anomaly Score')

show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique.
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Tutoriel utilisation algorithme Isolation Forest

2022-05-27T17:30:09Z

Mdesmet : Page créée avec « Tutoriel d’utilisation de l’algorithme Isolation forest Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra comme... »

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ''

nom_variable =''

<nowiki># Reste du code à ne pas modifier</nowiki>

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

<nowiki>model.fit(df[[nom_variable]])</nowiki>

<nowiki>model.predict(df[[nom_variable]])</nowiki>

<nowiki>df['scores']=model.decision_function(df[[nom_variable]])</nowiki>

<nowiki>
df['anomaly']=model.predict(df[[nom_variable]])</nowiki>

anomaly=df.loc[df['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

== Utilisation du model==

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''

La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)
''

Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''<nowiki># valeur à entrer</nowiki>

var1 = '’

var2 = ''

<nowiki># Code à ne pas modifier</nowiki>

pred_scores = -1*model.score_samples(df)

plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')

plt.colorbar(label='Simplified Anomaly Score')

show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique.
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T17:29:56Z

Mdesmet : /* Tuto Code */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au sein d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voitures, ordinateurs, montres connectées…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être dû à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

[[Fichier:Tutoriel.pdf]]

Ou sur la page wiki suivante :
[[Tutoriel utilisation algorithme Isolation Forest]]

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Wiki tuto

2022-05-27T17:27:21Z

Mdesmet : /* 4.3 Utilisation du model */

Wiki tuto

2022-05-27T17:24:03Z

Mdesmet : /* 4.3 Utilisation du model */

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ''

nom_variable =''

<nowiki># Reste du code à ne pas modifier</nowiki>

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

<nowiki>model.fit(df[[nom_variable]])</nowiki>

<nowiki>model.predict(df[[nom_variable]])</nowiki>

<nowiki>df['scores']=model.decision_function(df[[nom_variable]])</nowiki>

<nowiki>
df['anomaly']=model.predict(df[[nom_variable]])</nowiki>

anomaly=df.loc[df['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

===4.3 Utilisation du model===

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''

La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)
''

Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''<nowiki># valeur à entrer</nowiki>

var1 = '’

var2 = ''

<nowiki># Code à ne pas modifier</nowiki>

pred_scores = -1*model.score_samples(df)

plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')

plt.colorbar(label='Simplified Anomaly Score')

show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Wiki tuto

2022-05-27T17:23:18Z

Mdesmet : /* 4.3 Utilisation du model */

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ''

nom_variable =''

<nowiki># Reste du code à ne pas modifier</nowiki>

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

<nowiki>model.fit(df[[nom_variable]])</nowiki>

<nowiki>model.predict(df[[nom_variable]])</nowiki>

<nowiki>df['scores']=model.decision_function(df[[nom_variable]])</nowiki>

<nowiki>
df['anomaly']=model.predict(df[[nom_variable]])</nowiki>

anomaly=df.loc[df['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

===4.3 Utilisation du model===

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''
La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)
df_modif['anomaly']=model.predict(df)
''
Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''<nowiki># valeur à entrer</nowiki>

var1 = '’

var2 = ''

<nowiki># Code à ne pas modifier</nowiki>

pred_scores = -1*model.score_samples(df)

plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')

plt.colorbar(label='Simplified Anomaly Score')

show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Wiki tuto

2022-05-27T17:22:35Z

Mdesmet : /* 3 BIS Recherche anomalie pour une seule variable */

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ''

nom_variable =''

<nowiki># Reste du code à ne pas modifier</nowiki>

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

<nowiki>model.fit(df[[nom_variable]])</nowiki>

<nowiki>model.predict(df[[nom_variable]])</nowiki>

<nowiki>df['scores']=model.decision_function(df[[nom_variable]])</nowiki>

<nowiki>
df['anomaly']=model.predict(df[[nom_variable]])</nowiki>

anomaly=df.loc[df['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

===4.3 Utilisation du model===

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''
La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)
df_modif['anomaly']=model.predict(df)
''
Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]
anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''# valeur à entrer
var1 = '’
var2 = ''
# Code à ne pas modifier
pred_scores = -1*model.score_samples(df)
plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')
plt.colorbar(label='Simplified Anomaly Score')
show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Wiki tuto

2022-05-27T17:21:36Z

Mdesmet : /* 3 BIS Recherche anomalie pour une seule variable */

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ''

nom_variable =''

<nowiki># Reste du code à ne pas modifier</nowiki>

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df[[nom_variable]])

model.predict(df[[nom_variable]])

df['scores']=model.decision_function(df[[nom_variable]])

df['anomaly']=model.predict(df[[nom_variable]])

anomaly=df.loc[df['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

===4.3 Utilisation du model===

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''
La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)
df_modif['anomaly']=model.predict(df)
''
Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]
anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''# valeur à entrer
var1 = '’
var2 = ''
# Code à ne pas modifier
pred_scores = -1*model.score_samples(df)
plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')
plt.colorbar(label='Simplified Anomaly Score')
show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Wiki tuto

2022-05-27T17:19:34Z

Mdesmet : /* 2 Import des bibliothèques */

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

''#Valeur que vous devez entrez
nom_fichier = ''
nom_variable =''

# Reste du code à ne pas modifier
model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)
model.fit(df[[nom_variable]])
model.predict(df[[nom_variable]])
df['scores']=model.decision_function(df[[nom_variable]])
df['anomaly']=model.predict(df[[nom_variable]])
anomaly=df.loc[df['anomaly']==-1]
anomaly_index=list(anomaly.index)
print(anomaly)''

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

===4.3 Utilisation du model===

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''
La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)
df_modif['anomaly']=model.predict(df)
''
Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]
anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''# valeur à entrer
var1 = '’
var2 = ''
# Code à ne pas modifier
pred_scores = -1*model.score_samples(df)
plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')
plt.colorbar(label='Simplified Anomaly Score')
show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Wiki tuto

2022-05-27T17:19:16Z

Mdesmet : /* 1 ) Tutoriel */

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

''#Valeur que vous devez entrez
nom_fichier = ''
nom_variable =''

# Reste du code à ne pas modifier
model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)
model.fit(df[[nom_variable]])
model.predict(df[[nom_variable]])
df['scores']=model.decision_function(df[[nom_variable]])
df['anomaly']=model.predict(df[[nom_variable]])
anomaly=df.loc[df['anomaly']==-1]
anomaly_index=list(anomaly.index)
print(anomaly)''

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

===4.3 Utilisation du model===

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''
La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)
df_modif['anomaly']=model.predict(df)
''
Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]
anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''# valeur à entrer
var1 = '’
var2 = ''
# Code à ne pas modifier
pred_scores = -1*model.score_samples(df)
plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')
plt.colorbar(label='Simplified Anomaly Score')
show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Wiki tuto

2022-05-27T17:18:57Z

Mdesmet : /* 3 Recherche anomalie pour toute les variables¶ */

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties en italique entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----

<nowiki>#Valeur que vous devez entrez</nowiki>

nom_fichier = ""

<nowiki>#code à ne pas modifier</nowiki>

df = pd.read_csv(nom_fichier)

df_modif = pd.read_csv(nom_fichier)

model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)

model.fit(df)

df_modif['scores']=model.decision_function(df)

df_modif['anomaly']=model.predict(df)

anomaly=df_modif.loc[df_modif['anomaly']==-1]

anomaly_index=list(anomaly.index)

print(anomaly)

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

''#Valeur que vous devez entrez
nom_fichier = ''
nom_variable =''

# Reste du code à ne pas modifier
model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)
model.fit(df[[nom_variable]])
model.predict(df[[nom_variable]])
df['scores']=model.decision_function(df[[nom_variable]])
df['anomaly']=model.predict(df[[nom_variable]])
anomaly=df.loc[df['anomaly']==-1]
anomaly_index=list(anomaly.index)
print(anomaly)''

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

===4.3 Utilisation du model===

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''
La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)
df_modif['anomaly']=model.predict(df)
''
Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]
anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''# valeur à entrer
var1 = '’
var2 = ''
# Code à ne pas modifier
pred_scores = -1*model.score_samples(df)
plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')
plt.colorbar(label='Simplified Anomaly Score')
show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Wiki tuto

2022-05-27T17:15:39Z

Tutoriel d’utilisation de l’algorithme Isolation forest

Bienvenu dans ce tutoriel d’utilisation de l’algorithme Isolation forest. Ce tutoriel vous apprendra
comment utiliser facilement cet algorithme pour analyser votre propre banque de données. Il vous
fournira le code nécessaire mais aussi vous expliquera quels paramètres modifier si vous souhaitez
modifier le code pour l’adapter à vos besoins.

=1 ) Tutoriel=

Pour utiliser ce tutoriel correctement il faut créer un fichier .py par exemple où on copie toute les
parties en italique entre barres.

==1 Formatage des données==

Tout d'abord vous devez formater vos données afin qu'elles soient compatibles avec la suite de
ce tutoriel.

Pour cela créez un tableau sur excel ou autre tableur. La première colonne est l'identifiant qui
vous permettra d'identifier rapidement les anomalies qui vous seront indiquées, peut être le
numéro de la ligne par exemple.

Ensuite chaque colonne dont on mettra le titre en ligne 1 contiendra les valeurs d'une
caractéristique pour chaque élément de la base de données.
Finalement, enregistrez ce document sous le format cvs séparé par des virgules dans un
dossier de votre choix.

==2 Import des bibliothèques==

Vous devez maintenant créer un fichier dans le MEME dossier que celui où vous avez mis votre
dataset. Ce fichier est celui où nous allons écrire le programme une extension .py est donc conseillée.

Le fonctionnement de l’algorithme comme nous l’avons vu plus haut est assez complexe mais
heureusement des bibliothèque assez simplifiée ont étés crées ce qui va nous simplifier grandement
la tâche. Malheureusement ceci peut aussi nous désavantager car les seules fonctions qui sont
données sont très opaque et ne laisse peut de place à la compréhension du code interne et à la
modification de ce dernier. C’est pour cela que nous allons essayer de nous concentrer sur la
compréhension des arguments que nous donnons aux fonctions que nous allons utiliser.

----

''import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.ensemble import IsolationForest''

----

Si vous voulez trouver les anomalies en prenant en compte une seule variable de votre base de
donnez suivez la partie : "Recherche anomalie pour une seule variable". Si vous voulez connaitre
les annomalies en prenant en comptes toutes les variables entrées dans votre documents csv
suivez la partie : "Recherche anomalie pour toute les variable"

==3 Recherche anomalie pour toute les variables¶==

Dans cette section nous prenons en compte toute les variables entrées pour les éléments de notre
dataset.

----
''
#Valeur que vous devez entrez
nom_fichier = ''
#code à ne pas modifier
df = pd.read_csv(nom_fichier)
df_modif = pd.read_csv(nom_fichier)
model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)
model.fit(df)
df_modif['scores']=model.decision_function(df)
df_modif['anomaly']=model.predict(df)
anomaly=df_modif.loc[df_modif['anomaly']==-1]
anomaly_index=list(anomaly.index)
print(anomaly)''

----

Veuillez entrer le nom du fichier entre les guillemets sur la première ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset.

==3 BIS Recherche anomalie pour une seule variable==

Si vous souhaitez savoir qu’elles sont les valeurs anormales pour une seule variables, par exemple ne
prendre en compte que la variable de l’age dans une certaine population, il faut utiliser le code
suivant.

----

''#Valeur que vous devez entrez
nom_fichier = ''
nom_variable =''

# Reste du code à ne pas modifier
model=IsolationForest(n_estimators=50, max_samples='auto',
contamination=float(0.2),max_features=1.0)
model.fit(df[[nom_variable]])
model.predict(df[[nom_variable]])
df['scores']=model.decision_function(df[[nom_variable]])
df['anomaly']=model.predict(df[[nom_variable]])
anomaly=df.loc[df['anomaly']==-1]
anomaly_index=list(anomaly.index)
print(anomaly)''

----

Veuillez entrer le nom du fichier entre les guillemets sur la premiere ligne. Cela correspond au nom
du fichier créé en étape 1 contenant votre dataset. Ainsi que le titre de la colonne de la variable que
vous voulez prendre en compte dans nom_variable.

==4 Utiliser les résultats==

Lancez le programme. Ce dernier va vous affichez les valeurs dites anormales. Vous pouvez
ensuite agir sur ces dernières en utilisant la variable anomaly_index qui est un tableau qui
contient tous les indices des anomalies détectées.

=2)Explication plus précise du code=

Voici une explication plus précise de chaque fonction utilisée dans le code donné dans le tuto.

==1 Récupération des données==

Pour commencer, si nous avons bien suivi le tutoriel fournis nous avons déjà créée un fichier CSV qui
rassemble nos donnés. La fonction suivante permet de stocker toute ces informations dans une
variable en lisant le contenu de notre fichier.

''df = pd.read_csv(nom_fichier)
''

== 2 Création du model ==

Notre but maintenant est de définir le modèle utilisé par l’algorithme Isolation Forest ensuite. Cela
reviens à créer un objet contenant tous les paramètres donc la bibliothèque a besoin pour fonctionner.

Pour cela vous allez devoir choisir des paramètres suivants vos besoins :

===1) n_estimators===

Il s’agit ici de choisir le nombre d'estimateurs de base, c'est-à-dire le nombre d'arbres qui seront
construits dans la forêt.

Plus le nombre d’arbre est élevé plus l’algorithme est fiable car les moyennes souffrirons moins des
valeurs écartées mais ces calculs prennent du temps et son couteux c’est pour cela qu’un nombre trop
élevé d’arbre serait du « gâchis » car la plupart du temps ils n’apportent rien car les anomalies étaient
déjà isolées avec moins d’arbres.

On considère que 100 arbres sont suffisants pour quasiment toutes les applications courantes de
recherche d’anomalies c’est d’ailleurs la valeur par défaut.

===2)max_samples===

Il s’agit ici de choisir l’échantillon max soit le nombre d'échantillons à tirer pour former chaque
estimateur de base.

En effet lorsque l’on crée un arbre, surtout quand nous avons une grande banque de donnée nous
n’utilisons pas forcément tous les éléments de la base de donnée pour chaque arbres. Un échantillon
est créé pour n’utiliser que certaines données.

Vous pouvez changer cette valeur pour une valeur inferieur à 256 et aux nombres d’éléments dans
votre base de donnée si vous avez vraiment une contraintes de nombre d’opération à effectuer mais
celle si altèrera rapidement la qualité des résultats.

Vous pouvez mettre une valeur au dessus de 256 si votre base de donnée contient plus de 256
éléments et que vous n’avez pas peur d’une perte de rapidité et d’optimisation pour avoir un résultat
plus précis.

Il est tout de même conseillé de laisser ce paramètre en paramétrage automatique celui-ci choisira la
valeur min(256, n_samples) qui pour la plupart des application est nettement appropriée.
Le programme créera donc un nombre correspondant d’échantillons qui seront utilisés pour créer
chaque arbres.

===3) Contamination===

Ce paramètre est le plus sensible et le plus délicat à choisir. Le taux de contamination est la proportion
d’anomalies attendues dans la base de données.

Ce dernier est utilisé lors de l'ajustement pour définir le seuil sur les scores des échantillons. Il est
essentiel car si nous affirmons une valeur pour ce paramètre le code nous donneras un nombre de
valeur anormales correspondant. Par exemple si nous entrons contamination=float(0.2) le programme
nous fournira 20% de valeurs aberrantes même si les scores d’anomalies en révèle plus ou moins.
La valeur par défaut est 'auto'. Si 'auto', la valeur seuil sera déterminée comme dans l'article original
d'Isolation Forest.

Si nous connaissons cette valeur en revanche par exemple si nous savons d’avance que nous voulons
enlever 10% des valeurs qui sont trop éloignées des autres nous pouvons l’indiquer tout en sachant
qu’elle est comprise entre (0, 0.5]

===4) max_features ===

Comme nous l’avons vu dans l’explication du principe de isolation forest, l’algorithme va créer
des séparations parmi les données jusqu’à isoler les différents éléments.
Or il n’est pas forcements nécessaire de continuer de créer des séparations jusqu’à ce que
tous les éléments de la base de données soit isolés. En effet comme nous avons vu les
éléments les plus difficiles à isoler ne sont pas ceux qui sont considérés comme anormal. Le
nombre de séparation créées peut donc être paramétré pour optimiser l’algorithme.

La valeur par défaut est 1.0, on peut prendre une valeur différente mais cette dernière doit être
inferieur à 1.

===5) bootstrap===

Ce paramètre est un booléen, si on entre la valeur ‘Vrai’ cela indique que les tirages
d’échantillonnage pour chaque arbre est effectué avec remise, si ce paramètre est ‘Faux’ cela indique
cela indique que l’échantillonnage est fait sans remise.
Le réglage par défaut est False.

===6) n_jobs===

Ce paramètre permet de définir le nombre de tâche à exécuter en parallèle pour l’utilisation des
fonction fit et predict que nous expliquons plus loin.
Il n’est pas utile de se soucier de ce paramètre à moins que nous ayons une dataset de très très
grande taille.

Si sa valeur est ‘none’ une seule tâche est effectuée à la fois, si sa valeur est ‘-1’ le programme
utilisera alors tout le processeur disponible.

===7) random_state===
Ce paramètre contrôle le caractère pseudo-aléatoire de l’échantillonnage et du choix des splits, pour
chaque étape de création d’arbre.
C’est un entier qui suivant sa valeur appellera les fonctions si dessous plusieurs fois afin de faire des
moyennes des résultats pour accroire le caractère aléatoire des tirages faits.

===8) warm_start===

Ce paramètre est un booléen qui si il est paramétrer sur Vrai, réutilise la solution de l'appel
précédent pour s'adapter et rajoute seulement des estimateur dans l’ensemble. Si le paramètre
est Faux une toute nouvelle forêt est créée.
Ce paramètre peut être utile si vous utilisez une très grande base de donée et que vous pensez
qu’une précision supplémentaire est nécessaire.

Les paramètres conseillés sont les suivants :

model=IsolationForest(n_estimators=50, max_samples='auto', contamination= »auto »
,max_features=1.0, bootstrap=False, n_jobs=’None’, random_state=None,
warm_start=False)

===4.3 Utilisation du model===

Maintenant que nous avons défini le modèle avec lequel nous voulons travailler nous devons l’utiliser
pour l’appliquer à nos données.

Pour cela nous allons utiliser la fonction fit qui va ajuster le modèle sur les données. En d’autres mots
cette fonction crée tous les arbres de la forêt.

''model.fit(df)''

Nous utilisons ensuite la fonction decision_function qui va trouver le score d'anomalie de chaque
éléments en étudiants pour chacun leurs positions dans tout les arbres créés précédemment. Elle va
donc calculer le score d'anomalie moyen de X des classificateurs de base.

''model.decision_function(df)
''
La fonction predict va ensuite attribuer une valeur a chaque éléments qui indique si cet élément est
considéré comme normal (valeur 0) ou comme anomalie (-1) .

''model.predict(df)''

Pour plus de lisibilité nous plaçons ces deux scores dans notre tableau de données grâce aux fonctions
suivantes :

''df_modif['scores']=model.decision_function(df)
df_modif['anomaly']=model.predict(df)
''
Finalement nous cherchons un affichage correcte des résultats et pour cela nous isolons toute les
lignes correspondants à des anomalies pour les mettre dans un tableau séparé. Nous en profitons pour
isoler les index des anomalies dans une variable qui pourrait nous être utile plus tard.

''anomaly=df_modif.loc[df_modif['anomaly']==-1]
anomaly_index=list(anomaly.index)''

Et pour terminer nous affichons les lignes correspondants aux anomalies.

''print(anomaly)''

Pour visualiser les erreurs nous pouvons utiliser le code suivant.

----

''# valeur à entrer
var1 = '’
var2 = ''
# Code à ne pas modifier
pred_scores = -1*model.score_samples(df)
plt.scatter(df[[var1]],df[[var2]], c=pred_scores, cmap='RdBu')
plt.colorbar(label='Simplified Anomaly Score')
show()''

----

Veuillez choisir les deux noms des colonnes des variables que vous voulez choisir comme abscisse et
ordonnées de votre graphique
Cet affichage permet de visualiser l’ensemble des données ainsi que leurs score d’anomalies associé.
Cet affichages est très révélateur pour les base de données de dimensions 2 voire 3 mais pour les
dimensions plus élevées cet affichage perd de son intérêt.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T17:05:12Z

Mdesmet : /* Tuto Code */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au sein d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voitures, ordinateurs, montres connectées…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être dû à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

[[Fichier:Tutoriel.pdf]]

Ou sur la page wiki suivante :
[[wiki tuto]]

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T17:03:37Z

Mdesmet : /* Tuto Code */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au sein d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voitures, ordinateurs, montres connectées…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être dû à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

[[Fichier:Tutoriel.pdf]]

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Fichier:Tutoriel.pdf

2022-05-27T17:03:07Z

Mdesmet :

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T16:36:36Z

Mdesmet : /* Tuto Code */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au sein d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voitures, ordinateurs, montres connectées…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être dû à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

[[Fichier:Exemple.pdf]]

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Fichier:Schema6.png

2022-05-27T16:33:13Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schema6.png

Fichier:Schema5.png

2022-05-27T16:32:36Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schema5.png

Fichier:Schemaforest5.png

2022-05-27T16:32:07Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schemaforest5.png

Fichier:Schemaforest4.png

2022-05-27T16:31:18Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schemaforest4.png

Fichier:Schemaforest3.png

2022-05-27T16:30:38Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schemaforest3.png

Fichier:Schemaforest3.png

2022-05-27T16:30:18Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schemaforest3.png

Fichier:Schemaforest2.png

2022-05-27T16:29:45Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schemaforest2.png

Fichier:Schemaforest1.png

2022-05-27T16:25:17Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schemaforest1.png

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T16:23:02Z

Mdesmet : /* Tuto Code */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au sein d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voitures, ordinateurs, montres connectées…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être dû à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T16:22:15Z

Mdesmet : /* Tuto Code */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au sein d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voitures, ordinateurs, montres connectées…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être dû à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

Exemple d'utilisation du code

[[bd]]

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T16:20:50Z

Mdesmet : /* Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ? */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au sein d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voitures, ordinateurs, montres connectées…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être dû à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T16:17:38Z

Mdesmet : /* Résumé du principe */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :

1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage

2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Fichier:Schema6.png

2022-05-27T16:17:07Z

Mdesmet :

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T16:16:49Z

Mdesmet : /* C) Etude de la foret */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema6.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :
1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage
2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Fichier:Schema5.png

2022-05-27T16:15:58Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schema5.png

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T16:14:53Z

Mdesmet : /* C) Etude de la foret */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.png]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema5.png]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :
1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage
2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Fichier:Schemaforest5.png

2022-05-27T16:08:05Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schemaforest5.png

Fichier:Schemaforest4.png

2022-05-27T16:07:28Z

Mdesmet : Mdesmet a téléversé une nouvelle version de Fichier:Schemaforest4.png

Fichier:Schema5.png

2022-05-27T16:05:01Z

Mdesmet :

Fichier:Schemaforest5.png

2022-05-27T16:03:59Z

Mdesmet :

Fichier:Schemaforest4.png

2022-05-27T16:03:27Z

Mdesmet :

Fichier:Schemaforest3.png

2022-05-27T16:00:28Z

Mdesmet :

Fichier:Schemaforest2.png

2022-05-27T15:59:37Z

Mdesmet :

Fichier:Schemaforest1.png

2022-05-27T15:57:35Z

Mdesmet : n

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T15:57:01Z

Mdesmet : /* A) La construction d’un arbre */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schemaforest1.png]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schemaforest2.png]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schemaforest3.png]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schemaforest4.png]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schemaforest5.png]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.jpg]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema5.jpg]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :
1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage
2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Fichier:Schema1.png

2022-05-27T15:55:08Z

Mdesmet :

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T15:05:16Z

Mdesmet : /* Les limites de l’algorithme */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schema1.jpg]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schema2.jpg]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schema3.jpg]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schema4.jpg]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schema5.jpg]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.jpg]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema5.jpg]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :
1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage
2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :

- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T15:04:54Z

Mdesmet :

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

= Fonctionnement de l’algorithme Isolation Forest =

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

==A) La construction d’un arbre ==

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schema1.jpg]]

===Etape 1 : Sélection d’une variable et d’un seuil===

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schema2.jpg]]

===Etape 2 : étape itérative===

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schema3.jpg]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schema4.jpg]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schema5.jpg]]

== B) Construction d’une foret ==

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

== C) Etude de la foret ==

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.jpg]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema5.jpg]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

==Résumé du principe==

La détection d’anomalie d’erreur se fait en deux grandes étapes :
1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage
2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

= Tuto Code =

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

= Les limites de l’algorithme =

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :
- '''Le masquage''' : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- '''L’inondation''' : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- '''Donnés de haute dimension''' : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- '''Fausses anomalies''' : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-27T14:57:19Z

Mdesmet : /* Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ? */

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

=Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ?=

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

== Fonctionnement de l’algorithme Isolation Forest ==

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

A) La construction d’un arbre

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schema1.jpg]]

'''Etape 1 : Sélection d’une variable et d’un seuil'''

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schema2.jpg]]

'''Etape 2 : étape itérative'''

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schema3.jpg]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schema4.jpg]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schema5.jpg]]

'''B) Construction d’une foret'''

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

'''C) Etude de la foret'''

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.jpg]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema5.jpg]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

'''Résumé du principe'''

La détection d’anomalie d’erreur se fait en deux grandes étapes :
1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage
2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

3) Tuto Code

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

4) Les limites de l’algorithme

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :
- Le masquage : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- L’inondation : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- Donnés de haute dimension : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- Fausses anomalies : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-17T16:07:19Z

Mdesmet :

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

== Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but ? ==

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

== Fonctionnement de l’algorithme Isolation Forest ==

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

A) La construction d’un arbre

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps

[[Fichier:schema1.jpg]]

'''Etape 1 : Sélection d’une variable et d’un seuil'''

Nous sélectionnons aléatoirement une variable : ici nous avons le choix entre X et Y( mais en réalité bien plus de variables peuvent être prises en compte).
Nous repérons les valeurs :
- u max qui correspond à la valeur maximale prise par un élément de notre dataset pour cette variable
- u min qui correspond à la valeur minimale prise par un élément de notre dataset pour cette variable.
Après avoir trouvé cette plage de valeur, un valeur aléatoire de cette dernière est isolée est appelée u1.
Nous réalisons alors une découpe (aussi appelée split) de nos données au niveau de u1 et nous commençons donc la création de notre arbres qui va isoler :
- à droite : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur inférieur ou égale à u1
- à gauche : les éléments de notre population qui possèdent pour la variable sélectionnée une valeur supérieur à u1

[[Fichier:schema2.jpg]]

'''Etape 2 : étape itérative'''

Nous réitérons l’étape 1 jusqu’à ce que nous ayons un élément « isolé » dans notre arbre.
Alors nous créons le seuil U2 dans Y cette fois (aléatoirement) et nous complétons notre arbre.

[[Fichier:schema3.jpg]]

Ainsi de suite jusqu’à l’isolation d’un élément au moins.
Dans notre exemple trois étapes suffisent pour isoler les deux points ici mis en noir.

[[Fichier:schema4.jpg]]

Maintenant que nous avons isoler ces deux points nous les enlevons de notre processus de calcul, autrement dit nous ne les prenons plus en compte dans les calculs de u min et u max et nous continuons d’itérer notre procédure jusqu’à ce que tout les points soient isolés dans une branche de l’arbre.

Voici le résultat final dans notre exemple

[[Fichier:schema5.jpg]]

'''B) Construction d’une foret'''

La création d’un seul et unique arbre ne suffit pas pour répondre tout de suite à notre problématique.
En effet il est possible d’isoler à tort un éléments suite à des valeurs très spécifiques choisies( par l’aléatoire).

Pour pallier ce risque nous allons relancer le processus avec la même méthode mais avec des sélections de variables et de seuils qui seront forcément différentes étant donné que ces valeurs sont choisies aléatoirement. Nous obtiendrons donc une « foret » d’arbres que nous allons étudier.

'''C) Etude de la foret'''

Maintenant que nous avons créé une foret d’arbre nous allons étudier ces derniers et ce qu’ils nous indiquent sur la population étudiée .

Pour ce faire nous considérons toujours l’idée qu’une valeur atypique est plus facile à isoler autrement dit : plus le nombre de split nécessaire pour isoler une observation particulière est bas plus il y a de chance que cette dernière soit une anomalie.

Nous parcourons donc chaque arbre et nous attribuons à chaque éléments de notre population un score d’isolation. Celui-ci est d’autant proche de 1 que le nombre de split qui a été réalisé pour isolé l’élément est faible. Et il est d’autant proche de 0.5 que le nombre de split qui a été réalisé pour isolé l’élément est élevé. Cela correspond à la profondeur de l’arbre qui a mené à ce point

Par exemple pour ce point qui semble anormal il a fallut 3 split pour l’isoler. Son score est donc proche de 1.

[[Fichier:schema5.jpg]]

Autre exemple pour ce point qui semble normal il a fallut 7 split pour l’isoler. Son score est donc proche de 0,5.

[[Fichier:schema5.jpg]]

Après avoir relevé les scores de chaque éléments pour chaque arbres de la foret nous faisons une moyenne pour chaque individu de la population ce qui lui donne un score d’anomalie définitif . Puis nous isolons les éléments qui ont les scores les plus élevés qui sont ceux qui ont le plus de chance d’être atypique. Le nombre d’éléments relevés dépend du taux d’anomalie précédemment indiqué.

'''Résumé du principe'''

La détection d’anomalie d’erreur se fait en deux grandes étapes :
1. La construction d’iTrees grâce à un ensemble de donné d’apprentissage
2. Chaque instance de l’ensemble de test se voit attribué un score d’anomalie grâce à l’analyse de la foret créée a l’étape précédente

3) Tuto Code

Un des objectifs de ce projet était de créer un tutoriel permettant à toute personne d'utiliser facilement cet algorithme pour détecter des anomalie dans un dataset donné.

Voir le fichier sur le lien suivant :

4) Les limites de l’algorithme

Cet algorithme fonctionne très bien surtout sur les échantillons qui possèdent « peu » d’éléments ce qui est intéressant étant donné que la plupart des autres méthodes privilégient généralement une grande taille d’échantillonnage.
Quelques limites de cette méthode doivent tout de même êtres prisent en compte :
- Le masquage : Lorsque le nombre d’anomalie est trop élevé il peut arriver que celles-ci se regroupent dans un groupe dense et grand ce qui rend l’isolation de ces dernières plus difficile. Cela peut donc impacter la détection de ces points comme anomalie.

- L’inondation : si les instances normales sont trop proches des anomalies il est plus fastidieux d’isoler ces dernière ce qui tout comme le masquage impacte la bonne détection d’une anomalie comme telle du à une augmentation de split nécessaire pour l’isoler

- Donnés de haute dimension : Cette méthode étant basée sur la distance elle est altérée lorsque les éléments étudiés sont de trop hautes dimensions du aux fait que les points soient clairsemés dans l’espace de dimension élevé

- Fausses anomalies : D’autre part le système forest prend en paramètre un pourcentage de contamination (déjà limite en soi car il faut déjà avoir une idée du pourcentage de nos anomalies avant de lancé le programme) et ce pourcentage est respecté même si aucune anomalie ou une proportion plus faible d’anomalie est détectée. On entend par la que si 10% d’anomalie ont étés annoncé le programme nous renverra 10% d’anomalies même si tout les scores d’anomalies sont tous très proches et donc qu’aucune différence significative peut être observée entre les éléments du plan.

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-17T15:26:50Z

Mdesmet :

Détection d’anomalies par Isolation Forest : application pour l’industrie 4.0

2022-05-17T15:20:09Z

Mdesmet : Page créée avec « L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation. 1) Qu’est-ce que l’algorit... »

L'objectif de ce projet était d'étudier et comprendre l'algorithme Isolation Forest afin de pouvoir rédiger un tutoriel d'utilisation.

1) Qu’est-ce que l’algorithme de détection d’anomalie Isolation Forest et quel est son but

En quelque mots l’algorithme Isolation Forest est un algorithme non supervisé de machine Learning. Il est conçu pour détecter des valeurs anormales au seins d’un ensemble de données.

En effet de nos jours, beaucoup de données sont collectées grâce aux appareils connectés : voiture, ordinateur, montre connectée…. Ce développement de l’Internet of things nous impose de savoir collecter et traiter toute ces données de manière optimisée et efficace. Pour cela une des première étapes après la collecte des donnée est la détection d’anomalie.

Une anomalie dans un jeu de donnée est une valeur qui dénote des autres, ceci peut être du à un mauvais fonctionnement d’un capteur ( une température de 10 000 °C dans un four ) ou bien une action qui sors de l’ordinaire de la part de l’utilisateur (un retrait de 3 000 000 $ à un distributeur de billet d’un petit village). Détecter ces anomalies permet de pouvoir identifier un possible disfonctionnement qu’il faudra ignorer dans nos prochains calculs ou bien d’isoler des valeurs que nous allons étudier pour comprendre les causes de leur irrégularités. (par exemple détecter des actes de fraudes dans les paiements en carte de crédit).

2) Comment fonctionne l’algorithme Isolation Forest

Définitions utiles :

Dataset : Jeu de données en français est un ensemble de données associé , la plupart du temps représenté par un tableau ou un graph.

L’idée principale est de calculer un score d’anomalie pour chaque observation du dataset puis de comparer ces scores dans un second temps pour isoler les anomalies. Ceci est possible car nous nous basons sur l’idée qu’une donnée anormale sera plus facile à isoler qu’une donnée standard dû à son écart à ces dernières.

Pour comprendre le fonctionnement de cet algorithme nous allons l’illustrer avec un exemple en 2 dimensions X et Y.

2.A La construction d’un arbre

Nous plaçons nos données dans un graphique qui considère Y en fonction de X.
Voici à quoi ressemble notre data set dans un premier temps