rcavalie / PFE

Blame view

python/ANN.py 7.55 KB
Edit Raw Normal View History
4d6b688b   rcavalie   Réseau de neurone... 
1
2
3
4
5
6
7
 
  """
  Created on Thu Jan 18 14:28:42 2018
  @author: Robin Cavalieri
  Réseau de neurones 
  P32 : Apprentissage DoS
  PFE 2018 - IMA5SC Polytech Lille
  """
bdfec245   rcavalie   intégration du ré... 
8
 
  #Programme générique. N'oubliez pas de changer les PATHS
4d6b688b   rcavalie   Réseau de neurone... 
9
10
11
12
13
14
15
16
17
18
19
 
  ###############################################################################
  #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
4d6b688b   rcavalie   Réseau de neurone... 
20
 
  from keras.layers import Dense
f0cdc988   rcavalie   travail sur la ré... 
21
 
  from keras.models import model_from_json
4d6b688b   rcavalie   Réseau de neurone... 
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
 
  ###############################################################################
  
  ###############################################################################
  #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);
  ###############################################################################
f0cdc988   rcavalie   travail sur la ré... 
92
 
  ###############################################################################
4d6b688b   rcavalie   Réseau de neurone... 
93
 
  #TAUX DE REUSSITE A PARTIR DES DONNEES DE TEST
f0cdc988   rcavalie   travail sur la ré... 
94
 
  ###############################################################################
4d6b688b   rcavalie   Réseau de neurone... 
95
96
97
98
99
100
101
102
103
104
105
 
  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);
f0cdc988   rcavalie   travail sur la ré... 
106
 
  ###############################################################################
bdfec245   rcavalie   intégration du ré... 
107
f0cdc988   rcavalie   travail sur la ré... 
108
 
  ###############################################################################
bdfec245   rcavalie   intégration du ré... 
109
 
  #SAUVEGARDE DU TRAINING SET
f0cdc988   rcavalie   travail sur la ré... 
110
 
  ###############################################################################
bdfec245   rcavalie   intégration du ré... 
111
112
113
114
115
 
  #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
f0cdc988   rcavalie   travail sur la ré... 
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
 
  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;
      ###############################################################################