"""
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
import csv
# 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
###############################################################################

###############################################################################
#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(32, activation='relu', input_dim=2))
#Couche de sortie
classifier.add(Dense(1, 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 =1, epochs=10);
###############################################################################

###############################################################################
#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");
###############################################################################

##########################################################################################
#REALISER DES PREDICTIONS
##########################################################################################
dataset_to_pred = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/data_to_pred.csv', quoting=csv.QUOTE_NONE);
[xSizePred, ySizePred] = np.shape(dataset_to_pred);
data_to_pred = dataset_to_pred.iloc[:, 0: ySizePred].values;
predictions = classifier.predict(data_to_pred);

predictions_named = [];

for x in range(0, xSizePred-1):
    if predictions[x] > 0.5:
        predictions_named.append("Attaque")
    else:
        predictions_named.append("RAS")
##########################################################################################