ANN.py
7.55 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
"""
Created on Thu Jan 18 14:28:42 2018
@author: Robin Cavalieri
Réseau de neurones
P32 : Apprentissage DoS
PFE 2018 - IMA5SC Polytech Lille
"""
#Programme générique. N'oubliez pas de changer les PATHS
###############################################################################
#LIBRAIRIES UTILES
###############################################################################
import numpy as np
import pandas as pd
# Modelisation
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import confusion_matrix
# Réseau de neurones
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
###############################################################################
###############################################################################
#TRAVAIL PRELIMINAIRE DE TRAITEMENT DES DONNEES D'APPRENTISSAGE
###############################################################################
# Ouverture des bases d'apprentissage
dataset_ping_norm = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/ping_norm.csv');
dataset_ping_attack = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/ping_attack.csv');
dataset_rssi_norm = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/rssi_norm.csv');
dataset_rssi_attack = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/rssi_attack.csv');
#Concaténation des datasets de même classe 1-Normal 2- Attaque
temp = dataset_rssi_norm.iloc[:,1].values;
dataset_norm = np.c_[dataset_ping_norm, temp];
temp = dataset_rssi_attack.iloc[:,1].values;
dataset_attack = np.c_[dataset_ping_attack, temp];
#Concaténation des datasets de même type
dataset = np.concatenate((dataset_attack, dataset_norm), axis=0);
#Récupération de la taille des matrices de données
[nSizeX, nSizeY] = np.shape(dataset);
#On mélange les données pour éviter un apprentissage par fontière
np.random.shuffle(dataset);
#Sortie associée (correspond à la classe attaque ou non : colonne 1)
target = dataset[:, 0];
#Données d'entrée (ping : colonne 2 et rssi : colonne 3)
#data = dataset[:,1];
data = dataset[:,0:nSizeY-1];
#80% des données utilisées à l'entrainement et 20% des données en test
data_train, data_test, target_train, target_test = train_test_split(data, target, test_size = 0.2, random_state = 0);
#Normalisation des données
sc = StandardScaler();
data_train = sc.fit_transform(data_train);
data_test = sc.transform(data_test);
###############################################################################
###############################################################################
#ARCHITECTURE DU RESEAU DE NEURONES par le biais de la librairie KERAS
#ANN
###############################################################################
#Création du classifieur
classifier = Sequential();
#Couche d'entrée donc avec 2 entrées, PING et DELTA_RSSI
classifier.add(Dense(input_dim = nSizeY-1, output_dim = 3, init = 'uniform', activation = 'sigmoid'));
#Couche cachée
classifier.add(Dense(output_dim = 3, init = 'uniform', activation = 'sigmoid'));
#Sortie du réseau de neurones
classifier.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'));
###############################################################################
###############################################################################
#COMPILATION
###############################################################################
# optimizer : algorithme choisi pour trouver le model (le plus puissant)
# loss : Si deux valeurs en sortie (binairie outcome) : binary_crossentropy
classifier.compile(optimizer = 'rmsprop', loss = 'binary_crossentropy', metrics = ['accuracy']);
###############################################################################
###############################################################################
#TRAINING
###############################################################################
classifier.fit(data_train, target_train, batch_size =5, epochs=500);
###############################################################################
###############################################################################
#TAUX DE REUSSITE A PARTIR DES DONNEES DE TEST
###############################################################################
data_pred = classifier.predict(data_test);
# Conversion en True ou False les predictions
# Si y_pred > 0.5 : True
data_pred_binary = (data_pred > 0.5);
# Matrice de cout
cm = confusion_matrix(target_test, data_pred_binary);
#dire qu'un trafic normal est une attaque
good_prediction = cm[0, 0] + cm[1, 1];
#dire qu'une attaque est un trafic normal
bad_prediction = cm[1, 0] + cm[0, 1];
taux_succes = good_prediction * 100 / (good_prediction + bad_prediction);
###############################################################################
###############################################################################
#SAUVEGARDE DU TRAINING SET
###############################################################################
#Le modèle est mis au format JSON
classifier_json = classifier.to_json();
with open('C:/Users/Utilisateur/PFE/python/Training/training.json',"w") as json_file :
json_file.write(classifier_json);
#Les poids sont mis en HDF5
classifier.save_weights("C:/Users/Utilisateur/PFE/python/Training/training.h5");
###############################################################################
###############################################################################
#FONCTION DE PREDICTION APPELEE DANS LE MAIN
###############################################################################
def predictions(ping_mesured,rssi_mesured):
###############################################################################
#ARCHITECTURE DU RESEAU DE NEURONES par le biais de la librairie KERAS
#ANN
###############################################################################
#Création du classifieur
classifier = Sequential();
#Couche d'entrée donc avec 2 entrées, PING et DELTA_RSSI
classifier.add(Dense(input_dim = 2, output_dim = 3, init = 'uniform', activation = 'sigmoid'));
#Couche cachée
classifier.add(Dense(output_dim = 3, init = 'uniform', activation = 'sigmoid'));
#Sortie du réseau de neurones
classifier.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'));
###############################################################################
###############################################################################
#LOAD DU TRAINING SET
###############################################################################
json_file=open('C:/Users/Utilisateur/PFE/python/Training/training.json','r');
loaded_model_json=json_file.read();
json_file.close();
loaded_model=model_from_json(loaded_model_json);
loaded_model.load_weights('C:/Users/Utilisateur/PFE/python/Training/training.h5');
###############################################################################
###############################################################################
#REALISER DES PREDICTIONS
###############################################################################
dataset_to_pred = [ping_mesured, rssi_mesured];
predictions = classifier.predict(dataset_to_pred);
predictions_named = [];
if predictions > 0.5:
predictions_named.append(0);#NORMAL
#RAS
return 0;
else:
predictions_named.append(1);#ATTAQUE
#DETECTION d'ATTAQUE
return 1;
###############################################################################