TP: Création d'un Pare-feu Intelligent
Objectifs du TP
Ce TP a pour but de vous familiariser avec les techniques de prétraitement des
données et l'entraînement d'un modèle de Machine Learning pour créer un pare-feu
intelligent. Vous apprendrez à :
1. Nettoyer les données (gestion des valeurs manquantes, des doublons, et des formats
incorrects).
2. Encoder les données catégorielles (protocoles, types de connexion, etc.).
3. Normaliser les données numériques (ports, durées, bande passante, etc.).
4. Créer des caractéristiques (feature engineering) à partir des adresses IP, des ports, et des
logs réseau.
5. Entraîner et évaluer un modèle de Machine Learning pour détecter les connexions
malveillantes.
Énoncé du TP
Partie 1 : Charger les Données
1. Données Brutes :
Utilisez le jeu de données suivant contenant des informations sur des connexions
réseau :
data = {
"Adresse IP Source": ["[Link]", "[Link]", "[Link]", "[Link]", "[Link]"],
"Port Source": [5000, 80, 5000, 443, 80],
"Adresse IP Destination": ["[Link]", "[Link]", "[Link]", "[Link]",
"[Link]"],
"Port Destination": [80, 5000, 443, 80, 5000],
"Protocole": ["TCP", "HTTP", "TCP", "HTTPS", "HTTP"],
"Durée (s)": [10, 5, 8, 12, 6],
"Paquets": [100, 50, 80, 120, 60],
"Label": ["Normal", "Malveillant", "Normal", "Malveillant", "Normal"]
}
2. Créer un DataFrame :
Chargez les données dans un DataFrame Pandas.
import pandas as pd
# Données brutes
data = {
"Adresse IP Source": ["[Link]", "[Link]", "[Link]", "[Link]", "[Link]"],
"Port Source": [5000, 80, 5000, 443, 80],
Pr. Sara BAGHDADI ENSA KHOURIBGA
"Adresse IP Destination": ["[Link]", "[Link]", "[Link]", "[Link]", "[Link]"],
"Port Destination": [80, 5000, 443, 80, 5000],
"Protocole": ["TCP", "HTTP", "TCP", "HTTPS", "HTTP"],
"Durée (s)": [10, 5, 8, 12, 6],
"Paquets": [100, 50, 80, 120, 60],
"Label": ["Normal", "Malveillant", "Normal", "Malveillant", "Normal"]
}
# Créer un DataFrame
df = [Link](data)
# Afficher les données brutes
print("Données brutes :")
print(df)
Partie 2 : Nettoyage des Données
1. Gestion des Valeurs Manquantes :
Remplissez les valeurs manquantes dans la colonne "Durée (s)" par la moyenne.
# Remplacer les valeurs manquantes dans "Durée (s)" par la moyenne
df["Durée (s)"].fillna(df["Durée (s)"].mean(), inplace=True)
# Afficher les données après imputation
print("\\nDonnées après imputation :")
print(df)
2. Gestion des Doublons :
Supprimez les lignes en double.
# Supprimer les doublons
df.drop_duplicates(inplace=True)
# Afficher les données après suppression des doublons
print("\\nDonnées après suppression des doublons :")
print(df)
Partie 3 : Encodage des Données Catégorielles
1. Encodage One-Hot :
Transformez la colonne "Protocole" en utilisant l'encodage One-Hot.
# Encodage One-Hot pour la colonne "Protocole"
df = pd.get_dummies(df, columns=["Protocole"], prefix="Protocole")
# Afficher les données après encodage One-Hot
print("\\nDonnées après encodage One-Hot :")
print(df)
2. Encodage Label :
Pr. Sara BAGHDADI ENSA KHOURIBGA
Transformez la colonne "Label" en utilisant l'encodage Label (0 pour "Normal", 1 pour "Malveillant").
from [Link] import LabelEncoder
# Initialiser l'encodeur
encoder = LabelEncoder()
# Encodage Label pour la colonne "Label"
df["Label Encodé"] = encoder.fit_transform(df["Label"])
# Afficher les données après encodage Label
print("\\nDonnées après encodage Label :")
print(df)
Partie 4 : Normalisation des Données
1. Normalisation :
Normalisez les colonnes "Durée (s)" et "Paquets" pour les mettre à l'échelle dans l'intervalle [0, 1].
from [Link] import MinMaxScaler
# Initialiser le normaliseur
scaler = MinMaxScaler()
# Normaliser les colonnes "Durée (s)" et "Paquets"
df[["Durée (s)", "Paquets"]] = scaler.fit_transform(df[["Durée (s)", "Paquets"]])
# Afficher les données après normalisation
print("\\nDonnées après normalisation :")
print(df)
Partie 5 : Création de Caractéristiques (Feature Engineering)
1. Extraire des Informations des Adresses IP :
Extrayez les octets des adresses IP source et destination.
# Extraire les octets des adresses IP source
df["Octet1 Source"] = df["Adresse IP Source"].apply(lambda x: int([Link](".")[0]))
df["Octet2 Source"] = df["Adresse IP Source"].apply(lambda x: int([Link](".")[1]))
df["Octet3 Source"] = df["Adresse IP Source"].apply(lambda x: int([Link](".")[2]))
df["Octet4 Source"] = df["Adresse IP Source"].apply(lambda x: int([Link](".")[3]))
# Extraire les octets des adresses IP destination
df["Octet1 Destination"] = df["Adresse IP Destination"].apply(lambda x: int([Link](".")[0]))
df["Octet2 Destination"] = df["Adresse IP Destination"].apply(lambda x: int([Link](".")[1]))
df["Octet3 Destination"] = df["Adresse IP Destination"].apply(lambda x: int([Link](".")[2]))
df["Octet4 Destination"] = df["Adresse IP Destination"].apply(lambda x: int([Link](".")[3]))
# Afficher les données après extraction des octets
print("\\nDonnées après extraction des octets :")
print(df)
2. Créer une Colonne "Type de Port" :
Pr. Sara BAGHDADI ENSA KHOURIBGA
Classez les ports source et destination en "Ports connus" (0-1023), "Ports enregistrés" (1024-49151), et
"Ports dynamiques" (49152-65535).
# Fonction pour classifier les ports
def classifier_port(port):
if 0 <= port <= 1023:
return "Connu"
elif 1024 <= port <= 49151:
return "Enregistré"
else:
return "Dynamique"
# Appliquer la classification aux ports source et destination
df["Type de Port Source"] = df["Port Source"].apply(classifier_port)
df["Type de Port Destination"] = df["Port Destination"].apply(classifier_port)
# Afficher les données après classification des ports
print("\\nDonnées après classification des ports :")
print(df)
Partie 6 : Entraînement d'un Modèle de Machine Learning
1. Séparation des Données :
Divisez les données en ensembles d'entraînement et de test.
from sklearn.model_selection import train_test_split
# Séparer les caractéristiques (X) et la cible (y)
X = [Link](columns=["Label", "Label Encodé", "Adresse IP Source", "Adresse IP Destination"])
y = df["Label Encodé"]
# Diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Afficher les dimensions des ensembles
print("Dimensions de X_train :", X_train.shape)
print("Dimensions de X_test :", X_test.shape)
2. Choix du Modèle :
Utilisez un modèle de classification, comme un arbre de décision.
from [Link] import DecisionTreeClassifier
# Initialiser le modèle
model = DecisionTreeClassifier(random_state=42)
# Entraîner le modèle
[Link](X_train, y_train)
# Afficher les performances du modèle
print("Score sur l'ensemble d'entraînement :", [Link](X_train, y_train))
print("Score sur l'ensemble de test :", [Link](X_test, y_test))
1. Évaluation du Modèle :
Pr. Sara BAGHDADI ENSA KHOURIBGA
Évaluez les performances du modèle en utilisant des métriques comme la précision, le rappel, et
la matrice de confusion.
from [Link] import classification_report, confusion_matrix
# Faire des prédictions sur l'ensemble de test
y_pred = [Link](X_test)
# Afficher le rapport de classification
print("\\nRapport de classification :")
print(classification_report(y_test, y_pred))
# Afficher la matrice de confusion
print("\\nMatrice de confusion :")
print(confusion_matrix(y_test, y_pred))
Pr. Sara BAGHDADI ENSA KHOURIBGA
