

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.
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
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])
Dans cette section, je vais explorer les données afin de mieux les comprendre.
Ce bout de code vous permet:
#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
Cette partie est donc réservée aux prétraitement des données.
Voici les différentes tâches que j’ai faites:
#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']
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)
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.
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)
Partagez l'article à vos réseaux: on Twitter on Facebook on Google+ on LinkedIn
Je suis Jonas Agbakou, un passionné et professionnel de la Data Science. J’aime partager plus efficacement mes expériences et donc permettre à ceux qui ont soif de connaissance et souhaiteraient découvrir de nouvelles choses de bien approfondir leurs compétences.
Previous post