import pandas as pd
import numpy as np
import [Link] as plt
import seaborn as sns
import nltk
from [Link] import tqdm
from wordcloud import WordCloud
from sklearn.model_selection import train_test_split
from [Link] import SVC
from [Link] import classification_report, confusion_matrix
from transformers import AutoModel, AutoTokenizer
from [Link] import LabelEncoder
from [Link] import make_pipeline
from [Link] import StandardScaler
import torch
import re
[Link] as pd : Bibliothèque utilisée pour manipuler des données sous forme de tableaux
(DataFrame). Idéale pour lire des fichiers CSV ou Excel, organiser et analyser des données.
[Link] as np : Bibliothèque pour effectuer des calculs mathématiques et manipulation
d'objets multidimensionnels, comme des vecteurs et matrices.
[Link] as plt : Utilisé pour créer des visualisations (graphes, histogrammes, etc.).
[Link] as sns : Extension de matplotlib pour créer des visualisations statistiques avec des
graphiques esthétiques.
[Link] : Bibliothèque pour le Traitement Automatique des Langues (NLP). Elle facilite le
prétraitement des données textuelles, comme la tokenisation et la lemmatisation.
[Link] : Affiche une barre de progression lors des opérations lentes, surtout en
traitement de données ou entrainement de modèles.
[Link] : Génère des nuages de mots, une visualisation qui met en évidence les mots
fréquents dans un texte.
8.train_test_split : Fonction pour diviser un dataset en deux sous-ensembles : un pour
l'entraînement et l'autre pour le test.
[Link] : Support Vector Classifier, un algorithme d'apprentissage supervisé qui trouve un
hyperplan optimal pour séparer les classes dans les données.
10.classification_report et confusion_matrix : Fonctions pour évaluer les performances du
modèle. Elles génèrent un rapport détaillé (précision, rappel, F1-score) et une matrice de
confusion.
[Link] et AutoTokenizer : Permettent de charger facilement des modèles pré-entraînés
et leurs tokenizers avec la bibliothèque Hugging Face. Utile pour des tâches NLP comme
BERT.
[Link] : Encode des étiquettes (catégories de texte) sous forme de nombres.
13.make_pipeline : Simplifie la création d'une chaîne de traitement (prétraitement + modèle).
[Link] : Normalise les données pour améliorer les performances de modèles
comme SVM.
[Link] : Bibliothèque utilisée pour la manipulation de tenseurs et l’apprentissage
automatique (liée à PyTorch).
[Link] : Module pour la manipulation des expressions régulières, souvent utilisées pour
nettoyer le texte.
# Téléchargements nécessaires pour NLTK
[Link]('punkt')
[Link]('stopwords')
[Link]('wordnet')
from [Link] import stopwords
from [Link] import WordNetLemmatizer
# Initialisation des outils NLTK
lemmatizer = WordNetLemmatizer()
stop_words = set([Link]('english'))
1. Les trois commandes [Link]() téléchargent les ressources nécessaires pour
tokeniser les textes (punkt), supprimer les mots inutiles comme "the" ou "and"
(stopwords), et effectuer la lemmatisation via WordNet (wordnet).
2. Les outils initialisés incluent un lemmatiseur (réduction des mots à leur forme de
base) et une liste de mots vides pour le filtrage.
3. Ces éléments sont essentiels pour nettoyer les données textuelles avant de les utiliser
dans un modèle, en améliorant leur qualité pour l'analyse.
from transformers import pipeline
# Chargement des données
df = pd.read_excel('/content/[Link]')
df = df[['Text','Sentiment']] # On garde uniquement la colonne 'Text'
Ce code importe un pipeline Transformers, charge un fichier Excel contenant des messages
(Text) et leurs sentiments (Sentiment), puis garde uniquement ces colonnes pour l'analyse.
# Downloading the punkt_tab resource
[Link]('punkt') # This line downloads the required resource.
from [Link] import stopwords
# Fonction de prétraitement des textes
def preprocess_text(text):
text = [Link]()
text = [Link](r'[^\w\s]', '', text) # Suppression de la ponctuation
tokens = nltk.word_tokenize(text) # Tokenisation
tokens = [word for word in tokens if word not in stop_words] #
Suppression des stopwords
tokens = [[Link](word) for word in tokens] #
Lemmatisation
return ' '.join(tokens)
df['clean_text'] = df['Text'].apply(preprocess_text)
# Chargement du modèle BERT pour les embeddings
bert_model = AutoModel.from_pretrained("bert-base-uncased")
bert_tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
1. Prétraitement des textes : Une fonction transforme le texte en minuscules, supprime
la ponctuation, effectue une tokenisation, enlève les stopwords, puis lemmatise chaque
mot avant de reformer une version nettoyée du texte.
2. Application du prétraitement : Cette fonction est appliquée à la colonne Text du
DataFrame pour créer une nouvelle colonne appelée clean_text.
3. Chargement du modèle BERT : Le modèle BERT pré-entraîné et son tokenizer sont
chargés depuis la bibliothèque Transformers, prêts pour générer des embeddings à
partir des textes prétraités.
# Fonction pour extraire les embeddings de BERT
def get_bert_embeddings(text):
inputs = bert_tokenizer(text, return_tensors="pt", padding=True,
truncation=True, max_length=512)
with torch.no_grad():
outputs = bert_model(**inputs)
embeddings = outputs.last_hidden_state[:, 0, :].squeeze(0) #
Utiliser le CLS token
return [Link]()
# Extraction des embeddings pour chaque texte
[Link]() # Suivi des étapes
df['embeddings'] = df['clean_text'].progress_apply(get_bert_embeddings)
# Définir les labels pour le harcèlement
harassment_labels = ['toxic', 'severe_toxic', 'obscene', 'threat',
'insult', 'identity_hate']
# Initialiser le modèle
classifier = pipeline("text-classification", model="unitary/toxic-bert",
tokenizer="bert-base-uncased")
# Définir les labels pour le harcèlement
1. Extraction des embeddings de BERT : La fonction get_bert_embeddings
transforme le texte en format d'entrée pour BERT, obtient les embeddings à partir du
dernier état caché, et extrait le vecteur associé au token CLS, représentant la séquence
entière.
2. Application aux textes : Les embeddings BERT sont générés pour chaque message
dans la colonne clean_text et ajoutés sous une nouvelle colonne embeddings du
DataFrame.
3. Définition des labels de harcèlement : La liste harassment_labels contient des
catégories spécifiques identifiées comme comportements toxiques.
4. Initialisation du classifieur : Le pipeline unitary/toxic-bert permet de classifier
les textes en fonction des labels définis, aidant à détecter les messages harcelants.
# Fonction pour détecter le harcèlement
def annotate_message(message):
results = classifier(message)
# Vérification du label retourné par le modèle BERT
for result in results:
label = result['label'].lower()
score = result['score']
if label in harassment_labels and score >= 0.3:
return 1 # Harcèlement détecté
# Si aucun harcèlement n'est détecté, vérifier le sentiment du
message
# Ici on suppose que le sentiment est déjà dans le dataframe sous
forme de 'clean_text'
if df[df['clean_text'] == message]['Sentiment'].iloc[0] ==
'Negative':
return 1 # Harcèlement basé sur le sentiment 'Negative'
return 0 # Pas de harcèlement détecté
# Annoter les messages
[Link]() # Suivi des étapes
df['label'] = df['clean_text'].progress_apply(annotate_message)
print([Link])
1. Fonction annotate_message :
Cette fonction utilise le classifieur BERT pour analyser un message. Elle vérifie si le
message contient des labels de harcèlement (par exemple, 'toxic', 'threat', etc.) avec un
score supérieur à 0,3. Si ces conditions sont remplies, elle retourne 1 (harcèlement
détecté).
2. Vérification du sentiment négatif :
Si le modèle BERT ne détecte pas de harcèlement, le sentiment du message est vérifié
dans le DataFrame. Si le sentiment est 'Negative', le message est considéré comme du
harcèlement (1).
3. Annotation des messages :
Chaque message du DataFrame df est annoté en appliquant la fonction
annotate_message, et la colonne label est créée avec les résultats (1 pour
harcèlement, 0 pour pas de harcèlement).
Clarification du seuil de 0.3 :
Le score de 0.3 représente le seuil pour considérer qu'un message est potentiellement toxique
ou harcelant. Cela signifie qu'une probabilité de 30% ou plus que le message appartienne à un
des labels de harcèlement est suffisante pour le marquer comme harcelant. Ce seuil peut être
ajusté en fonction du contexte ou des résultats souhaités
# Préparer les données pour le SVM
X = [Link](df['embeddings'])
y = df['label']
# Encodage des labels
le = LabelEncoder()
y = le.fit_transform(y)
# Diviser les données en ensemble 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, stratify=y)
# Entraîner un SVM
svm_model = make_pipeline(StandardScaler(), SVC(kernel='linear',
probability=True))
svm_model.fit(X_train, y_train)
# Prédiction sur le jeu de test
y_pred = svm_model.predict(X_test)
print("Classification Report :\n", classification_report(y_test,
y_pred))
# Visualisation avec WordCloud des textes toxiques
toxic_texts = ' '.join(df[df['label'] == 1]['clean_text'])
wordcloud = WordCloud(background_color='white', max_words=100,
width=800, height=400).generate(toxic_texts)
[Link](figsize=(10, 5))
[Link](wordcloud, interpolation='bilinear')
[Link]('off')
[Link]()
Le code extrait les embeddings de BERT, prépare les données pour un modèle SVM, puis
entraîne ce modèle pour détecter le harcèlement dans les messages. Il divise les données en
ensembles d'entraînement et de test, normalise les données, puis entraîne le modèle SVM avec
un noyau linéaire. Ensuite, il évalue le modèle à l'aide d'un rapport de classification et génère
un nuage de mots pour visualiser les mots associés aux messages toxiques.
import tkinter as tk
from tkinter import messagebox
def show_alert():
root = [Link]()
[Link]() # Masquer la fenêtre principale
[Link]("Alerte de Harcèlement", "Le message contient
du harcèlement. Veuillez prendre des mesures.")
[Link]()
# Exemple de prédiction pour un nouveau message
new_message = input("Entrez un message à tester : ")
clean_message = preprocess_text(new_message)
embedding_message = get_bert_embeddings(clean_message).reshape(1, -1)
prediction = svm_model.predict(embedding_message)
probability = svm_model.predict_proba(embedding_message)
if prediction[0] == 1:
print(f"ALERTE: Le message contient du harcèlement. Veuillez prendre
des mesures. (probabilité : {probability[0][1]:.2f}).")
else:
print("Le message ne contient pas de harcèlement.")
1. Interface Tkinter : Utilisation de tkinter pour créer une fenêtre pop-up d'alerte en
cas de détection de harcèlement.
2. Prédiction du message : Le message de l'utilisateur est prétraité, transformé en
embedding via BERT, puis évalué par le modèle SVM.
3. Alerte : Si le message est classé comme harcelant (prédiction 1), une alerte est
affichée avec la probabilité associée, sinon un message indique que le contenu n'est
pas harcelant.
Entrez un message à tester : You’re too sexy
ALERTE: Le message contient du harcèlement. Veuillez prendre des
mesures. (probabilité : 1.00).