Apprentissage automatique utilisant Scikit-Learn
Nesrine Ammar 05-03-2019
PROGRES
Apprentissage
Données d’apprentissage
Algorithme d’apprentissage
Nouvelles h
exemple Prédictions
Apprentissage
X1 X2
…
Xn y→ Non spam
→ Spam
Apprentissage
X1 X2
…
Xn yX_train
X_test
y_train
y_test
70%
30%
Apprentissage
Import sklearn
Import pandas as pd
From sklearn.linear_model import LinearRegression dataset = pd.read_csv(‘filename.csv’)
train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42) y_train, y_test= train_set[‘labels’], test_set[‘labels’]
X_train, X_test= train_set.drop(‘labels’, axis=1), test_set.drop(‘labels’, axis=1) Lin_reg =LinearRegression()
Lin_reg.fit(X_train, y_train)
Apprentissage
Import sklearn
Import pandas as pd Import numpy as np
Some_data = X_train[:3]
Some_labels = y_train[:3]
Print (‘predictions:’, lin_reg.predict(some_data)) predictions = lin_reg.predict(X_test)
mae = np.mean(abs(predictions - y_test))
print(‘LinearRegression Performance on the test set: MAE = %0.4f' % mae)
Classification binaire
From sklearn.linear_model import DecisionTreeClassifier Sgd_clf = DecisionTreeClassifier()
Sgd_clf.fit(X_train, y_train) Sgd_clf.predict([un mail])
>> True
From sklearn.model_selection import cross_val_score
cross_val_score(sgd_clf, X_train, y_train, cv=3, scoring=‘accuracy’)
>> [0.9502, 0.96565, 0.96495]
Classification binaire
From sklearn.linear_model import DecisionTreeClassifier Sgd_clf = DecisionTreeClassifier()
Sgd_clf.fit(X_train, y_train) Sgd_clf.predict([un mail])
>> spam
Sgd_clf.predict_proba([un mail])
>> [0.1, 0.9]
Classification binaire
Cross_val_score → permet d’évaluer un model utilisant la technique k-folds en divisant le train_set en k-folds, ensuite permet de faire des prédictions et évaluer sur chaque fold avec un modèle entrainé sur le reste des folds.
From sklearn.model_selection import cross_val_score
Cross_val_score(model, X_train, y_train, cv=3, scoring=accuracy)
>> [0.9, 0,91, 0,99]
Matrice de confusion
Un moyen bien meilleur d'évaluer les performances d'un classificateur est d'examiner la matrice de confusion. l'idée générale est de compter le nombre de fois où des instances de la classe A sont classées en classe B.
La matrice de confusion est un outil utilisé en apprentissage supervisé servant à mesurer la qualité d'un système de classification.
Pour calculer la matrice de confusion → nous avons besoin d’avoir un ensemble de prédictions afin de les comparer aux labels actuels
On peut faire les prédictions sur le test_set → on le laisse à la fin du projet
→ On va calculer les prédictions sur le train_set utilisant la cross validation
Matrice de confusion
Matrice de confusion
From sklearn.model_selection import cross_val_predict tree= DecisionTreeClassifier()
Tree.fit(X_train, y_train)
Y_train_predictions = tree.predict(X_train)
From sklearn.metrics import confusion_matrix Confusion_matrix(y_train, y_train_predictions)
>> [[53272, 1307], [1077, 4344]]
Matrice de confusion
From sklearn.metrics import confusion_matrix
Confusion_matrix(y_train, y_train_perfect_predictions)
>> [[53272, 0], [0, 4344]]
Matrice de confusion
Négative
Négative
Positive
Positive
Actuels
Prédictions
Matrice de confusion
Négative
Négative
Positive
Positive
Actuels
Prédictions
TN
TP FP
FN
Matrice de confusion (parfaite)
Négative
Négative
Positive
Positive
Actuels
Prédictions
TN
TP FP
FN
Matrice de confusion
Négative
Négative
Positive
Positive
Actuels
Prédictions
Vrai négatif
Vrai positif Faux négatif
Faux positif
Précision/Rappel
La matrice nous donne encore plus d’information:
→ Proportion des prédictions positives (correctes) parmi les valeurs qui ont été prédites comme positives
→ Proportion des prédictions positives (correctes) parmi les valeurs positives dans l’ensemble de données testées.
Précision/Rappel
Négative
Négative
Positive
Positive
Actuels
Prédictions
Précision
Rappel
Précision/Rappel
From sklearn.metrics import precision_score, recall_score Precison_score(y_train_5, y_train_predictions)
>> 0.7689
Recall_score(y_train_5, y_train_predictions)
>>0.8013
Multi-classification
Tree = DecisionTreeClassifier() Tree.fit(X_train, y_train)
Tree.predict([un chiifre])
>> 6
tree.predict_proba([un chiffre])
>>[]
y_predictions = tree.predict(X_train)
confusion_M = confusion_matrix(y_train, y_predictions) Print confusion_M
Multi-classification
Actuels
Prédictions
Pandas
In [1]: df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'], ...: 'B': ['B0', 'B1', 'B2', 'B3'],
...: 'C': ['C0', 'C1', 'C2', 'C3'], ...: 'D': ['D0', 'D1', 'D2', 'D3']}, ...: index=[0, 1, 2, 3])
...:
In [2]: df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'], ...: 'B': ['B4', 'B5', 'B6', 'B7'],
...: 'C': ['C4', 'C5', 'C6', 'C7'], ...: 'D': ['D4', 'D5', 'D6', 'D7']}, ...: index=[4, 5, 6, 7])
...:
In [3]: df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'], ...: 'B': ['B8', 'B9', 'B10', 'B11'],
...: 'C': ['C8', 'C9', 'C10', 'C11'], ...: 'D': ['D8', 'D9', 'D10', 'D11']}, ...: index=[8, 9, 10, 11])
...:
In [4]: frames = [df1, df2, df3]
In [5]: result = pd.concat(frames)
Pandas
In [8]: df4 = pd.DataFrame({'B': ['B2', 'B3', 'B6', 'B7'], ...: 'D': ['D2', 'D3', 'D6', 'D7'],
...: 'F': ['F2', 'F3', 'F6', 'F7']}, ...: index=[2, 3, 6, 7])
...:
In [9]: result = pd.concat([df1, df4], axis=1, sort=False)
Pandas
In [10]: result = pd.concat([df1, df4], axis=1, join='inner’) → Intersection selon les indexes
Pandas
In [12]: result = df1.append(df2) result = df1.append(df4, sort=False)
Pandas
In [38]: left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'], ....: 'A': ['A0', 'A1', 'A2', 'A3'],
....: 'B': ['B0', 'B1', 'B2', 'B3']}) ....:
In [39]: right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'], ....: 'C': ['C0', 'C1', 'C2', 'C3'],
....: 'D': ['D0', 'D1', 'D2', 'D3']}) ....:
In [40]: result = pd.merge(left, right, on='key')
Projet: classification des types d’objets connectés
Les attributs de flux de trafic:
→ Un flux est une succession de paquets entre une source et une destination caractérisé par le 4- tuplet (IP source, IP destination, port source, port destination).
• La taille moyenne des paquets ainsi que la taille maximum et minimum;
• Le temps moyen des temps inter-arrivées des paquets d’un flux;
• La taille du flux mesurée en nombre de paquets ;
• Les protocoles utilisés : HTTP, HTTPS, SSDP, mDNS, TFTP, DHCP, DNS, NTP, BOOTP, TCP, UDP.
Projet: classification des types d’objets connectés
Projet: classification des types d’objets connectés
Les attributs textuels:
Certaines données peuvent être extraites des messages en clair au niveau applicatif.
Ces données textuelles contiennent des mots clés caractérisant l’objet connecté. Tout d’abord, les données sont nettoyées en éliminant les symboles et les chiffres, afin d’obtenir un ensemble de
mots uniques. Ensuite, les données textuelles sont modélisées par un sac de mots : on génère un vecteur binaire `a partir de l’ensemble des mots uniques extraits dont la valeur est définie à 1 si le mot
existe dans la description de l’objet, 0 sinon.
• Le nom du fabricant à partir de l’adresse MAC;
• Le nom de l’objet `a partir de DHCP;
• Le nom du fabricant, le modèle, le nom familier et le type `a partir de la description XML partagée
• par le protocole de découverte UPnP;
• Le nom local et les services offerts par l’objet `a partir des enregistrement du protocole mDNS;
• Le système d’exploitation, le modèle et parfois le type à partir de l’agent utilisateur inclus dans la requête HTTP, principalement pour les objets mobiles.
