Détection des commentaires Spams dans YOUTUBE avec machine learning
1. Motivation
Les commentaires Spams ont fortement augmenté ces dernières années sur les chaînes des créateurs YouTube.
Plusieurs d’entre eux ont exprimé leur frustration face aux commentaires malveillants se faisant passer pour eux afin d’arnaquer leurs téléspectateurs.
Cela devient donc un problème important à résoudre.
Pour résoudre ce problème, j’utilise dans cet article une approche basée sur le machine learning.
2. Importation des plugins importants
J’ai utilisé le langage PYTHON. En PYTHON, avant d’utiliser un plugin il faut l’importer. Pour cela, cette section présente tous les plugins utilisés.
import pandas as pd
import pickle
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.ensemble import RandomForestClassifier
3. Collection des données
Un modèle de machine est ”données + Algorithme”. Cette section est donc consacrée aux données utilisées.
J’ai utilisé un Data Set contenant des commentaires de YouTube. Il s’agit d’un Data Set public contenant des commentaires collectés pour la détection de Spams. Le Data Set est disponible ici.
Il dispose de cinq Data Sets composés de 1956 commentaires réels extraits à partir de cinq vidéos qui ont été parmi les 10 les plus vues sur la période de collecte.
Ce code vous permet de regrouper les cinq Data Sets en un seul.
#Collection des données
df1 = pd.read_csv("Youtube01-Psy.csv")
df2 = pd.read_csv("Youtube02-KatyPerry.csv")
df3 = pd.read_csv("Youtube03-LMFAO.csv")
df4 = pd.read_csv("Youtube04-Eminem.csv")
df5 = pd.read_csv("Youtube05-Shakira.csv")
#Concatennation des cinq Data Sets en un seul
df = pd.concat([df1, df2,df3,df4,df5])
4. Exploration des données
Dans cette section, je vais explorer les données afin de mieux les comprendre.
Ce bout de code vous permet:
- d’afficher rapidement la liste des colonnes contenues dans le Data Set
- d’afficher les cinq premières lignes du Data Set
- de connaitre le nombre de colonnes et de lignes
- de vérifier s’il existe des valeurs nulls
#Afficher les colonnes
list(df.columns)
#Afficher les cinq premières lignes
df.head()
#Afficher le nombre de colonnes et de lignes
df.shape
#Vérifier les valeurs nulls
df.isnull().sum()
#Afficher la repartition des données dans la CLASS
counts= df["CLASS"].value_counts()
counts
5. Prétraitement des données pour le machine learning
- En machine learning, il est important d’utiliser les données de qualité car GIGO=GARBAGE IN GARBAGE OUT. Ce qui signifie que des données d’entrée défectueuses ou absurdes produisent des sorties absurdes ou “déchets”. Et cela peut conduire à des mauvaises décisions. L’étape du prétraitement des données est très importante pour le machine learning car elle permet d’avoir des données de qualités et compréhensibles par les algorithmes de machine learning.
Cette partie est donc réservée aux prétraitement des données.
Voici les différentes tâches que j’ai faites:
- Extraire uniquement le CONTENT et la CLASS à partir du Data set
- Enlever les stopwords(Mot vide) dans le contenu des commentaires(CONTENT)
- Tokeniser le CONTENT
- Lemmatiser CONTENT
- Encoder le CONTENT avec countVectorizer
- Scinder le Data set en données d’entraînement (75%) et de test(25%)
#Extractions des caracteristiques importantes
df_data = df[['CONTENT', 'CLASS']]
df_data.head()
# Enlever les stopwords dans le contenu des commentaires
stop = stopwords.words('english')
df_data['ContentWithNoStopWords'] = df_data['CONTENT'].apply(lambda x: ' '.join([word for word in x.split() if word not in (stop)]))
df_x=df_data['ContentWithNoStopWords']
df_x.shape
# tokenisation
df_x['tokenized_Content'] = df_x.apply(word_tokenize)
df_x['tokenized_Content']
#Lemmatisation
lmtzr = WordNetLemmatizer()
df_x['tokenized_Content'] = df_x['tokenized_Content'].apply(
lambda lst:[lmtzr.lemmatize(word) for word in lst])
df_x['tokenized_Content'].shape
# Extraire les données de la colonne CLASS
df_y = df_data.CLASS
# Afficher les cinq premieres lignes
df_y.head()
# Encoder les carateristiques avec countVectorizer
cv = CountVectorizer()
X = cv.fit_transform(df_x['tokenized_Content'].astype('str'))
# Afficher les dimmensions
X.shape
# Scinder les données en données d'entrainement et de test
X_train, X_test, y_train, y_test = train_test_split(X, df_y, test_size = 0.25, random_state = 42)
target_names = ['No Spam', 'Spam']
6. Modélisation et validation
Dans cette partie je vais procéder à la modélisation et validation en utilisant les algorithmes suivants: la régression logistique, le SVM, Naive Bayes et le Random Forest.
# ------------------Naive Bayes----------------------------------------
# L'entrainemnt avec Naive Bayes
NaiveBayes= MultinomialNB()
NaiveBayes.fit(X_train, y_train)
# Le Test avec Naive Bayes et calcul d'Accuracy
NaiveBayes.score(X_test, y_test)
y_predNB =NaiveBayes.predict(X_test)
# Afficher le rapport de classification
classification_report(y_test,y_predNB,target_names=target_names)
# ------------------Regression Logistique ----------------------------------------
# L'entrainemnt avec la Regression Logistique
logisticRegr = LogisticRegression()
logisticRegr.fit(X_train, y_train)
# Le Test avec la regression logistique et le calcul d'Accuracy
y_predRL =logisticRegr.predict(X_test)
logisticRegr.score(X_test, y_test)
# Afficher le rapport de classification
classification_report(y_test,y_predRL,target_names=target_names)
# ------------------Random Forest ----------------------------------------
# L'entrainemnt avec Random Forest
RandomForest=RandomForestClassifier(n_estimators=100)
RandomForest.fit(X_train,y_train)
# Le Test avec la regression logistique et le calcul d'Accuracy
y_predRF=RandomForest.predict(X_test)
RandomForest.score(X_test, y_test)
# Afficher le rapport de classification
classification_report(y_test,y_predRF,target_names=target_names)
# ------------------SVM----------------------------------------
# L'entrainemnt avec SVM
SVM= svm.SVC()
SVM.fit(X_train,y_train)
# Le Test avec SVM et le calcul d'Accuracy
y_predSVM=SVM.predict(X_test)
SVM.score(X_test, y_test)
#Afficher le rapport de classification
classification_report(y_test,y_predSVM,target_names=target_names)
7.Choix du modèle champion
Avant de choisir le meilleur modèle, je vous explique les métriques que j’ai utilisé. J’ai utilisé le Recall, Precision et f1-score qui permettent d’évaluer la capacité des modèles pour la détection des commentaires Spams(CLASS=1).
Recall: correspond au nombre de commentaires correctement attribués à la classe SPAM(1) par rapport au nombre total de commentaires appartenant à la classe SPAM(1) (total des vrais positifs).
Precision: correspond au nombre de commentaires correctement attribués à la classe SPAM(1)par rapport au nombre total de commentaires prédits comme appartenant à la classe SPAM(1) (total prédit positif).
F1-score: donne le meilleure compromis entre Recall et Precision.
NB: Étant donné que le Data Set n’est pas déséquilibré, nous pouvons aussi utiliser l’ACCURACY.
Vous pouvez remarquer sur le tableau ci-dessous que les modèles de Random Forest, Logistic Regression et SVM ont donné les meilleurs f1-score. Parmi ces trois modèles, le modèle de Random Forest a donné la meilleure Precision. Donc je choisis le modèle de Random Forest comme le modèle King.
8. Sauvegarde du modèle pour déploiement
Le modèle le plus performant retenu est celui qui utilise l’algorithme de Random Forest.
Ce bout de code permet de sauvegarder le modèle en format pickle. Ce dernier représente notre modèle final, qui peut être utilisé pour faire des prédictions sur des commentaires de YOUTUBE.
with open(r"MODEL.pickle", "wb") as output_file:
pickle.dump(RandomForest, output_file)
You may also like
Ce que vous devez savoir sur ETL
