Il existe un filtre anti-spam dans presque toutes les plateformes d'emailing ou de messagerie. Le filtre examine chaque e-mail ou message à son arrivée et le classe comme spam ou ham. Votre boîte de réception affiche ceux qui relèvent du jambon. Il rejette ou affiche séparément les messages qui relèvent du spam.
Vous pouvez créer votre propre filtre anti-spam en utilisant NLTK, regex et scikit-learn comme bibliothèques principales. Vous aurez également besoin d'un jeu de données pour entraîner votre modèle.
Comprendre votre jeu de données
« Spam Classification for Basic NLP » est une Jeu de données Kaggle. Il contient un mélange de spam et de messages bruts de jambon. Il comporte 5 796 lignes et 3 colonnes.
Le CATÉGORIE colonne indique si un message est un spam ou un jambon. Le numéro un représente le spam tandis que le zéro représente le jambon. Le
MESSAGE colonne contient le courrier brut réel. Le NOM DE FICHIER catégorie est un identifiant de message unique.Préparation de votre environnement
Pour suivre, vous aurez besoin d'un compréhension de base de Python et l'apprentissage automatique. Vous devez également être à l'aise de travailler avec Colab Google ou bloc-notes Jupyter.
Pour Jupyter Notebook, accédez au dossier dans lequel vous souhaitez que le projet réside. Créez un nouvel environnement virtuel et exécutez le Jupyter Notebook à partir de ce dossier. Google Colab n'a pas besoin de cette étape. Créez un nouveau bloc-notes dans Google Colab ou Jupyter Notebook.
Le code source complet et le jeu de données sont disponibles dans un Référentiel GitHub.
Exécutez la commande magique suivante pour installer les bibliothèques requises.
!pip install nltk scikit-learn regex numpy pandasVous utiliserez :
- NLTK pour traitement du langage naturel (PNL).
- scikit-learn pour créer le modèle d'apprentissage automatique.
- regex pour travailler avec des expressions régulières.
- NumPy pour travailler avec des tableaux.
- Pandas pour manipuler votre ensemble de données.
Importer des bibliothèques
Importez les bibliothèques que vous avez installées dans votre environnement. Importez la bibliothèque regex en tant que re et scikit-learn en tant que sklearn.
importer pandas comme pd
importer numpy comme np
importer nltk
depuis nltk.stem importer WordNetLemmatizer
depuis nltk.corpus importer mots vides
importer concernant
depuis sklearn.model_selection importer train_test_split
depuis sklearn.metrics importer rapport_classification
depuis sklearn.feature_extraction.text importer CountVectorizer
depuis sklearn.feature_extraction.text importer TfidfVectorizer
Vous utiliserez WordNetLemmatizer et les modules de mots vides de NLTK pour prétraiter les messages bruts dans l'ensemble de données. Vous utiliserez des modules sklearn importés lors de la construction du modèle.
Prétraitement des données
Appelez la fonction pandas read_csv pour charger le jeu de données. Assurez-vous de stocker le jeu de données dans le même répertoire que votre projet. Affichez les cinq premières lignes du jeu de données pour obtenir un visuel du jeu de données.
df = pd.read_csv('/content/Spam Email texte brut pour NLP.csv')
df.head()Supprimez la colonne FILE_NAME de l'ensemble de données. Ce n'est pas une fonctionnalité utile pour la classification des spams.
df.drop('NOM DE FICHIER', axe=1, en place=Vrai)Vérifiez le nombre de courriers indésirables et de spam dans l'ensemble de données. Cela vous aidera plus tard à déterminer comment diviser les données pour la formation et les tests du modèle.
df. CATÉGORIE.value_counts()Téléchargez les mots vides du corpus depuis la bibliothèque NLTK. Les mots vides sont un ensemble de mots courants. Le prétraitement les supprime des messages. Chargez les mots vides en anglais et stockez-les dans une variable de mots vides.
nltk.download('mots vides')
mot vide = nltk.corpus.stopwords.words('Anglais')Téléchargez le WordNet multilingue ouvert. Il s'agit d'une base de données lexicales de mots anglais et de leurs significations sémantiques.
nltk.download('omw-1.4')Télécharger le corpus wordnet. Vous l'utiliserez pour la classification de texte. Instancie un objet WordNetLemmatizer(). Vous utiliserez l'objet lors de la lemmatisation. La lemmatisation est une technique utilisée en PNL pour réduire les formes dérivationnelles des mots à leur sens dans le dictionnaire.
Par exemple: Réduire le mot « chats » vous donnera « chat ». Un mot après lemmatisation devient un lemme.
nltk.download('wordnet')
lemmatizer = WordNetLemmatizer()Créez une liste vide que vous utiliserez pour stocker les messages prétraités.
corpus=[]Créez une boucle for pour traiter chaque message dans la colonne MESSAGE de l'ensemble de données. Supprimez tous les caractères non alphanumériques. Convertissez le message en minuscules. Divisez le texte en mots. Supprimez les mots vides et lemmatisez les mots. Reconvertir les mots en phrases. Ajoutez le message prétraité dans la liste de corpus.
pour je dans plage (len (df)):
# supprimer tous les caractères non alphanumériques
message = re.sub('[^a-zA-Z0-9]', ' ', df['MESSAGE'][je])# convertir le message en minuscule
message = message.inférieur()# diviser la phrase en mots pour la lemmatisation
message = message.split()# suppression des mots vides et lemmatisation
message = [lemmatizer.lemmatize (mot) pour mot dans message
si mot pasdans définir (mots vides.mots('Anglais'))]# Reconvertir les mots en phrases
msg = ' '.join (message)
# Ajout du message prétraité à la liste des corpus
corpus.append (message)
Cette boucle prendra environ cinq minutes à parcourir. L'étape de lemmatisation et de suppression des mots vides prend la plupart du temps. Vous avez maintenant prétraité vos données.
Ingénierie des fonctionnalités à l'aide du modèle de sac de mots par rapport à la technique TF-IDF
L'ingénierie des fonctionnalités est le processus de conversion des fonctionnalités de données brutes en nouvelles fonctionnalités adaptées aux modèles d'apprentissage automatique.
Modèle de sac de mots
Le modèle de sac de mots représente les données textuelles comme une distribution de fréquence des mots présents dans le document. C'est simplement le nombre de fois qu'un mot apparaît dans un document.
Utilisez la classe CountVectorizer de scikit-learn pour convertir les données textuelles en vecteurs numériques. Ajustez le corpus de messages prétraités et transformez le corpus en une matrice creuse.
# Prenez les 2500 meilleures fonctionnalités
cv = CountVectorizer (max_features=2500, ngram_range=(1,3))
X = cv.fit_transform (corpus).toarray()
y = df['CATÉGORIE']Divisez les données transformées en ensembles d'apprentissage et de test. Utilisez vingt pour cent des données pour les tests et quatre-vingts pour cent pour la formation.
x_train, x_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, état_aléatoire=1, stratifier=y)Le modèle de sac de mots classera correctement les messages dans l'ensemble de données. Mais ne fonctionnera pas bien dans la classification de vos propres messages. Il ne tient pas compte du sens sémantique des messages. Pour classer uniquement les messages dans l'ensemble de données, utilisez cette technique.
Technique TF-IDF
Le terme fréquence-fréquence inverse du document (TF-IDF) fonctionne en attribuant des poids aux mots dans un document en fonction de leur fréquence d'apparition. TF-IDF donne un poids plus élevé aux mots qui apparaissent fréquemment dans un document mais qui sont rares dans le corpus. Cela permet aux algorithmes d'apprentissage automatique de mieux comprendre le sens du texte.
tf = TfidfVectorizer (ngram_range=(1,3), max_features=2500)
X = tf.fit_transform (corpus).toarray()
x_train, x_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, état_aléatoire=1, stratifier=y)
Pour extraire la signification sémantique des messages et classer vos propres messages, utilisez TF-IDF.
Création et formation de votre modèle
Commencez par créer et initialiser un modèle Naive Bayes à l'aide de la classe scikit-learn MultinomialNB.
modèle = MultinomialNB()Ajustez les données d'entraînement, permettant au modèle de s'entraîner sur l'ensemble d'entraînement :
model.fit (x_train, y_train)Faites ensuite des prédictions sur les ensembles d'apprentissage et de test à l'aide de la méthode de prédiction.
train_pred = model.predict (x_train)
test_pred = model.predict (x_test)Ces prédictions vous aideront à évaluer votre modèle.
Évaluation du modèle
Évaluez les performances de votre modèle à l'aide de la fonction classification_report de scikit-learn. Transmettez les prédictions de l'ensemble d'apprentissage et les étiquettes d'ensemble d'apprentissage réelles en entrée. Faites de même pour l'ensemble de test.
imprimer (classification_report (train_pred, y_train))
imprimer (classification_report (test_pred, y_test))Plus la précision, le rappel et l'exactitude sont élevés pour les deux classes, meilleur est le modèle.
Résultats de la classification de vos propres messages
Transformez le message en vecteur en utilisant la technique TF-IDF. Utilisez le modèle pour prédire si le message est un spam ou un jambon, puis affichez cette prédiction à l'écran.
imprimer('Prédire...')msg = ["Vous avez gagné 10000 dollars, veuillez fournir votre compte
détails, afin que nous puissions transférer l'argent"]
message_vector = tf.transform (message)
catégorie = model.predict (message_vector)
imprimer("Le message est", "courrier indésirable"si catégorie == 1autre"pas de spam")
Remplacez le message par le vôtre.
La sortie est la suivante :
Le modèle peut classer les nouveaux messages non vus comme spam ou jambon.
Le défi de la classification des spams dans les applications
Le principal défi auquel est confrontée la classification des spams dans les applications est la mauvaise classification des messages. Les modèles d'apprentissage automatique ne sont pas toujours corrects. Ils peuvent classer le spam comme du jambon et vice-versa. Dans le cas de la classification de ham comme spam, un programme peut supprimer les e-mails de la boîte de réception de l'utilisateur, ce qui lui fait manquer des messages importants.
