Les fausses nouvelles sont des informations fausses ou trompeuses présentées comme des nouvelles. Les fausses nouvelles ont souvent pour but de nuire à la réputation d'une personne ou d'une entité ou de gagner de l'argent grâce aux revenus publicitaires. La prévalence des fausses nouvelles a augmenté avec la récente montée des médias sociaux, et cette désinformation s'infiltre progressivement dans les médias grand public. Plusieurs facteurs ont été impliqués dans la diffusion de fausses nouvelles, tels que la polarisation politique, la politique post-vérité, le raisonnement motivé, le biais de confirmation et les algorithmes des médias sociaux.

Description du jeu de données

Cet ensemble de données remonte à 2016 ; à l'époque, il y avait un afflux de fausses nouvelles sur toutes les plateformes médiatiques, en particulier sur les réseaux sociaux, où de nombreuses fausses nouvelles entourant les élections américaines étaient activement publiées. La diffusion de fausses nouvelles tournait principalement autour du scandale des e-mails d'Hillary Clinton.

Forme

L'ensemble de données a une forme de (12 999, 20), indiquant 12 999 lignes et 20 colonnes. Chaque ligne représente une publication (publiée sur une plateforme de médias sociaux) dans l'ensemble de données. Chaque point de données, à son tour, contient 20 caractéristiques et colonnes de publication différentes.

Fonctionnalités

Notre analyse se concentre principalement sur les attributs suivants de l'ensemble de données :

1. author (string) : nom de la personne qui a écrit la fake news.
2. publié (dateheure) : met en évidence la date et l'heure de publication ou de mise en ligne de l'actualité.
3. title (string) : représente le titre de l'actualité qui est utilisé pour l'affichage.
4. text (string) : représente le texte principal (corps) de l'actualité publiée.
5. language (string) : indique la langue dans laquelle l'actualité a été publiée.
6. site_url (string) : indique l'URL du site sur lequel la fake news a été publiée.
7. country (string) : indique le pays dans lequel la fake news a été publiée.
8. spam_score (double) : Probabilité que le message ait été marqué comme spam par le logiciel.
9. type (string) : cet attribut indique le genre (catégorie) de la publication de fake news qui représente le but de la publication.

La première étape de toute analyse exploratoire des données consiste à examiner l'ensemble de données et à le nettoyer. Nous avons remarqué que certaines lignes de notre ensemble de données avaient des valeurs nulles. Au lieu d'imputer les lignes avec des valeurs nulles, nous avons décidé de supprimer ces lignes en raison de la grande taille de l'ensemble de données. Cela n'affecte pas les résultats de notre étude car ces lignes étaient beaucoup moins nombreuses que la taille de notre ensemble de données.

Corrélations

fig = plt.figure(figsize=(8, 8))
sns.heatmap(df.corr(), annot=True)
plt.show()

      
                

                    
                    
                
            

df.drop(['uuid', 'ord_in_thread', 'domain_rank', 'country', 'main_img_url', 
         'replies_count', 'participants_count', 'thread_title', 'title',          
         'crawled', 'likes', 'comments', 'shares'], 
          axis=1, inplace=True)

Les chaînes stockées dans la colonne « auteur » ont été réduites ; seuls les alphabets et les chiffres ont été conservés.

df['author'] = df['author'].str.lower().replace('[^a-z0-9\s]')

df['text'] = df['text'].str.lower() 
df['text'] = df['text'].str.replace('[^\w\s]', '') 
df['text'] = df['text'].str.replace('\d+', '') 
df['text'] = df['text'].str.replace(r'\s+', ' ', regex=True) 
df['text'] = df['text'].str.replace(r'\r+|\n+|\t+', '', regex=True)

df['Published Year']  = df['published'].str.split("-").str[0]
df['Published Month'] = df['published'].str.split("-").str[1]
df['Published Day']   = df['published'].str.split("-").str[2].str.slice(0, 2)

df.drop(['published'], axis=1, inplace=True)

L'analyse exploratoire des données (EDA) est le processus d'exploration des données, de génération d'informations, de test d'hypothèses, de vérification des hypothèses et de révélation des modèles cachés sous-jacents. Le nettoyage de l'ensemble de données et la réalisation d'une analyse approfondie des données exploratoires sont des processus nécessaires et une excellente occasion d'établir les bases d'un modèle d'apprentissage automatique solide.

Nous répondons aux questions suivantes à l'aide d'EDA :

Quels mois de 2016 ont eu la plus forte concentration de fausses nouvelles dans notre ensemble de données sur les fausses nouvelles ?

À l'aide d'un graphique à secteurs, nous avons constaté qu'octobre et novembre avaient la plus forte concentration de fausses nouvelles.

Quels sont les 10 premiers mots qui apparaissent dans les messages Fake News ?

En explorant les mots fréquents, nous avons supprimé tous les mots vides de la colonne de texte entière, puis trouvé le nombre de mots de la colonne entière, puis sélectionné les 10 premiers mots qui apparaissaient le plus.

import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords 
stop_words = stopwords.words('english')
stop_words.append("us")
sw_df = df['text'].apply(lambda x: ' '.join([word for word in x.split() if word not in (stop_words)]))
bow = pd.Series([y for x in sw_df.values.flatten() for y in x.split()])
top_ten = bow.value_counts().nlargest(10)

      
                

                    
                    
                
            

Pour répondre à cette question, nous avons dessiné des sous-parcelles du nombre de valeurs des publications marquées comme fausses par l'outil par rapport à site_urls. Nos résultats auraient pu être utilisés pour signaler des sites afin d'ajuster leur classement de domaine ou empêcher ces sites d'apparaître aux utilisateurs. Notre étude a révélé que la distribution de fausses nouvelles était raisonnablement uniforme sur les site_urls.

Quels sont les 10 meilleurs auteurs qui ont publié le plus de fausses nouvelles dans notre ensemble de données ?

Pour trouver les 10 meilleurs auteurs qui ont publié le plus de fausses nouvelles, nous avons calculé la fréquence de chaque auteur dans notre ensemble de données et tracé le nombre de valeurs par rapport aux noms des auteurs sur un diagramme à barres.

Ingénierie des fonctionnalités

L'ingénierie des fonctionnalités utilise les connaissances du domaine pour extraire des fonctionnalités, telles que des caractéristiques, des propriétés et des attributs, à partir de données brutes. L'ingénierie des fonctionnalités facilite le processus d'apprentissage automatique et augmente la puissance prédictive des algorithmes d'apprentissage automatique en créant des fonctionnalités à partir de données brutes.

Pour que les machines donnent un sens aux données qualitatives, elles doivent d'abord être converties au format quantitatif. Par conséquent, pour atteindre notre objectif objectif, nous avons converti nos colonnes non numériques, telles que « auteur », « langue » et « site_url » en type de données numériques en alimentant ces colonnes avec un encodeur d'étiquettes.

from sklearn import preprocessing
str_column_names = ['author', 'language', 'site_url']
label_encoders = {}
for each_str_col_name in str_column_names:
    le = preprocessing.LabelEncoder()
    le.fit(df[each_str_col_name])
    df[each_str_col_name + '_t'] = le.transform(df[each_str_col_name])
    label_encoders[each_str_col_name] = le

cv = CountVectorizer(max_features=10000)
cv.fit(df['text'])
vecs_text = cv.transform(df['text']).toarray()

Une caractéristique essentielle du cycle de vie de la science des données est qu'il nécessite plusieurs itérations à chaque étape pour produire des informations précieuses. Une erreur critique que nous avons commise lorsque nous avons commencé notre étude a été de supprimer la colonne "auteur" en la supposant comme une information redondante. Il s'avère que la colonne « auteur » contient des informations précieuses pour déterminer la « fausseté » d'un message particulier. Nous avons rectifié notre erreur et décidé d'encoder les lignes avec des auteurs manquants comme anonymes.

df['author'].fillna('anonymous', inplace=True)

Nous avons remarqué que lorsque nous avons introduit les fonctionnalités de notre ensemble de données dans notre modèle, y compris la colonne "texte", les performances de notre modèle étaient catastrophiques.
Le score de précision était étonnamment très élevé (99%), mais le score F1 de notre modèle était maigre (presque 0,01). En y regardant de plus près, nous avons constaté une disparité significative entre le nombre de publications sur les réseaux sociaux qui ont franchi le seuil de spam_score de 0,5. Il y avait un grand nombre de messages marqués comme non faux et beaucoup moins de messages marqués comme faux. Lorsque nous avons calculé les scores de précision de nos modèles, ils ont mal classé le petit nombre de messages marqués comme "faux", obtenant ainsi des scores de précision aussi élevés et un score F1 presque nul. Nous avons finalement décidé de ne pas inclure la colonne "texte". Cette stratégie a énormément amélioré le score F1 de nos modèles. Continuez à lire pour découvrir les scores de précision dans la section Machine Learning de cet article.

Apprentissage automatique

Prédire les fausses nouvelles

Nous avons utilisé diverses techniques d'apprentissage automatique pour prédire si une publication sur les réseaux sociaux est fausse. Nous avons utilisé différents modèles de classification pour classer nos points de données selon le Label( spam_score ).

from sklearn.model_selection import train_test_split as tt_split
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier as RFC
from sklearn.metrics import f1_score

#75-25 Test-Train Split
X_train, X_test, Y_train, Y_test = tt_split(X, Y, test_size=0.25,
                                      shuffle=True, random_state=25)

Régression logistique

Nous avons appliqué le modèle de régression logistique de Sklearn et calculé la précision correspondante sur l'ensemble de test.

logreg =  LogisticRegression(solver='saga',penalty='elasticnet', 
              l1_ratio=0.5, max_iter=5000, class_weight='balanced', n_jobs = 4) 
logreg.fit(X_train, Y_train)

KNeighboursClassifier

K-NN est un algorithme d'apprentissage automatique robuste pour un ensemble de données très déséquilibré comme le nôtre. Nous avons essayé différentes valeurs de k et calculé les précisions moyennes correspondantes. Nous avons trouvé que le paramètre optimal pour la valeur de k est 1. Ceci est encore une fois dû au fort déséquilibre entre nos classes. La précision rapportée était de 98,2 % avec un score F1 de 0,49. KNN est une amélioration significative par rapport au classificateur de régression logistique.

RandomForestClassifier

Enfin, nous avons utilisé une méthode d'apprentissage automatique pour prédire les fausses nouvelles. Nous avons utilisé le modèle RF Classifier de sklearn pour cela. De plus, nous avons utilisé la méthode de validation croisée K-Fold pour améliorer la précision rapportée par notre algorithme. Il y parvient en divisant l'ensemble de données en 5 parties et en utilisant 4 parties différentes de manière itérative pour former le modèle et la partie restante pour tester la précision et d'autres mesures.

Le processus est décrit dans l'extrait suivant.

from sklearn.ensemble import RandomForestClassifier as RFC
from sklearn.model_selection import KFold
from sklearn.metrics import confusion_matrix
from sklearn.metrics import plot_confusion_matrix

kf = KFold(n_splits=5, random_state=None, shuffle=False)
accuracy_scores = []
confusion_matrices = []
f1_scores = [] 

for train_index, test_index in kf.split(X_train):    
    # Split the dataset
    X_train_k, X_test_k = X_train[train_index], X_train[test_index]
    Y_train_k, Y_test_k = Y_train[train_index], Y_train[test_index]
    
    # Fit the model
    rfc_model = RFC(n_estimators=2, max_depth=3, random_state=114)
    rfc_model.fit(X_train_k, Y_train_k)
    
    # Make Predictions
    Y_pred = rfc_model.predict(X_test_k)
    
    # Evaluation
    accuracy_scores.append(rfc_model.score(X_test_k, Y_test_k))
    f1_scores.append(f1_score(Y_test_k, Y_pred))
    
    # Find confusion matrix of each fold and append it to confusion_matrices list
    conf_matrix = confusion_matrix(Y_test_k, Y_pred)
    confusion_matrices.append(conf_matrix)

Le verdict final

Tout d'abord, nous avons discuté de ce qu'est une Fake News. Ensuite, nous avons étudié, nettoyé, visualisé et analysé notre ensemble de données à l'aide de diverses techniques. Nous avons nettoyé et conçu les fonctionnalités de notre ensemble de données afin que nos modèles d'apprentissage automatique puissent trouver des modèles dans notre ensemble de données. Nous avons exploré divers algorithmes de classification pour prédire ce qui est qualifié de Fake News et ce qui ne l'est pas. Notre étude a révélé que Random Forest Classifier est le meilleur algorithme pour prédire une classe de points de données lorsque nous avons un ensemble de données très asymétrique.

Les résultats de notre étude sont apportés par :

Muhammad Zain Ul Abidin [email protected]

Muhammad Shahmeer [email protected]

Muhammad Hamza [email protected]

Saifullah Shakeel [email protected]

Abdur Rehman Khalid [email protected]