Cet article a été publié dans le cadre du Blogathon sur la science des données
Cet article vise à comparer quatre algorithmes de deep learning et de machine learning différents pour créer un détecteur de spam et évaluer ses performances.. L'ensemble de données que nous avons utilisé provenait d'un échantillon aléatoire de sujets et de corps d'e-mails contenant à la fois du spam et des e-mails nuisibles dans de nombreuses proportions., que nous transformons en slogans. La détection de spam est l'un des projets d'apprentissage en profondeur les plus efficaces, mais c'est aussi souvent un projet où les gens perdent la confiance nécessaire pour rechercher le modèle le plus simple à des fins de précision. Dans cet article, nous allons détecter le spam dans le courrier en utilisant quatre techniques différentes et les comparer pour obtenir le modèle le plus précis.
POURQUOI LA DÉTECTION DE SPAM?
Un e-mail est devenu l'un des types de communication les plus importants. Dans 2014, on estime qu'il y a 4,1 1 milliard de comptes de messagerie dans le monde, et autour 196 1 milliard d'emails sont envoyés jour après jour dans le monde. Le spam est l'une des principales menaces présentées aux utilisateurs de messagerie. Tous les flux d'e-mails qui étaient du spam dans 2013 sont les 69,6%. Donc, une technologie efficace de filtrage du courrier indésirable contribue de manière significative à la durabilité du cyberespace et de notre société. Puisque l'importance de l'email n'est pas moindre que celle de votre compte bancaire contenant 1Cr., Le protéger du spam ou de la fraude est également obligatoire.
Préparation des données
Pour préparer les données, nous suivons les étapes ci-dessous:
1. Téléchargez les e-mails de spam et de jambon via Google à emporter sous forme de fichier boîte.
2. Lire les fichiers mbox dans les listes en utilisant le package 'mailbox'. Chaque élément de la liste contenait un e-mail individuel. Dans la première itération, nous incluons 1000 E-mails radioamateurs et 400 courriers indésirables (nous testons différentes proportions après la première itération).
3. Déballé chaque e-mail et concaténé son sujet et son corps. Nous avons également décidé d'inclure le sujet de l'e-mail dans notre analyse, car c'est également un excellent indicateur pour savoir si un e-mail est du spam ou du jambon..
4. Listes converties en blocs de données, trames de données de spam et de jambon jointes, et mélangé la trame de données résultante.
5. Divisez la trame de données en trames de données de test et de flux. Les données d'essai étaient les 33% à partir de l'ensemble de données d'origine.
6. Divisez le texte du courrier en slogans et appliquez la transformation TF-IDF à l'aide de CountVectorizer suivi du transformateur TF-IDF.
7. Quatre modèles ont été entraînés à l'aide des données d'entraînement:
- Bayes ingénieux
- Arbres de décision
- Machine à vecteur de soutien (SVM)
- Forêt aléatoire
8. Utiliser les modèles entraînés, étiquette d'e-mail prévue pour l'ensemble de données de test. Quatre métriques ont été calculées pour mesurer les performances des modèles en tant que précision, Précision, Récupération, note F, ASC.
CODE
1.Importer les bibliothèques
#importer toutes les bibliothèques nécessaires importer une boîte aux lettres %matplotlib en ligne importer matplotlib.pyplot en tant que plt importer csv à partir de textblob importer TextBlob importer des pandas importer sklearn #import cPickle importer numpy en tant que np de sklearn.feature_extraction.text importer CountVectorizer, Transformateur Tfidf depuis sklearn.naive_bayes importer MultinomialNB de sklearn.svm importer SVC, LinéaireSVC à partir de sklearn.metrics importer classification_report, f1_score, score_précision, confusion_matrice depuis sklearn.pipeline import Pipeline de sklearn.grid_search importer GridSearchCV à partir de sklearn.cross_validation importer StratifiedKFold, cross_val_score, train_test_split depuis sklearn.tree importer DecisionTreeClassifier de sklearn.learning_curve importer learning_curve #importer des bibliothèques de métriques à partir de sklearn.metrics importer confusion_matrix de sklearn.metrics importer precision_score de sklearn.metrics importer rappel_score à partir de sklearn.metrics importer f1_score à partir de sklearn.metrics importer roc_auc_score
2.Fonction pour obtenir le texte de l'e-mail à partir du corps de l'e-mail
def getmailtext(un message): #obtenir le texte brut « corps de l'e-mail »
corps = aucun
#vérifier si l'e-mail mbox comporte plusieurs parties
si message.is_multipart():
pour une partie de message.walk():
si part.is_multipart():
pour sous-partie dans part.walk():
si subpart.get_content_type() == 'texte/simple':
corps = subpart.get_payload(decode=Vrai)
elif part.get_content_type() == 'texte/simple':
corps = part.get_payload(decode=Vrai)
#si le message n'a qu'une seule partie
elif message.get_content_type() == 'texte/simple':
corps = message.get_payload(decode=Vrai)
#renvoyer le texte du courrier qui concatène à la fois le sujet et le corps du courrier
mailtext=str(un message['matière'])+" "+str(corps)
renvoyer le texte du courrier
3. Lire le fichier de courrier indésirable m-box
mbox = boîte aux lettres.mbox('Spam.mbox')
mlist_spam = []
#créer une liste qui contient le texte du courrier pour chaque message de spam
pour le message dans mbox:
mlist_spam.append(getmailtext(un message))
#Pause
#lire le fichier e-mail ham mbox
mbox_ham = boîte aux lettres.mbox('ham.mbox')
mlist_ham = []
compte=0
#créer une liste qui contient le texte du courrier pour chaque message électronique de jambon
pour le message dans mbox_ham:
mlist_ham.append(getmailtext(un message))
si compter>601:
Pause
compte+=1
4. Créer deux ensembles de données à partir d'e-mails de spam / jambon qui contiennent des informations telles que le texte de l'e-mail, l'étiquette d'envoi et la longueur de l'envoi.
#créer 2 dataframes pour les courriers indésirables de jambon qui contiennent les informations suivantes- #Texte du courrier, longueur du courrier, le courrier est étiquette jambon/spam importer des pandas au format pd spam_df = pd.DataFrame(mlist_spam, colonnes=["un message"]) spam_df["étiqueter"] = "pourriel" spam_df['longueur'] = spam_df['un message'].carte(texte lambda: longueur(texte)) imprimer(spam_df.head()) ham_df = pd.DataFrame(mlist_ham, colonnes=["un message"]) ham_df["étiqueter"] = "jambon" ham_df['longueur'] = ham_df['un message'].carte(texte lambda: longueur(texte)) imprimer(ham_df.head())
5.Fonction pour appliquer les transformations BOW et TF-IDF
def features_transform(courrier):
#obtenir le sac de mots pour le texte du courrier
bow_transformer = CountVectorizer(analyseur=split_into_lemmas).ajuster(mail_train)
#imprimer(longueur(bow_transformer.vocabulary_))
messages_bow = bow_transformer.transform(courrier)
#valeur de rareté d'impression
imprimer('forme de matrice clairsemée:', messages_bow.shape)
imprimer('nombre de non-zéros:', messages_bow.nnz)
imprimer('éparpillement: %.2F%%' % (100.0 * messages_bow.nnz / (messages_bow.shape[0] * messages_bow.shape[1])))
#appliquer la transformation TF-IDF à la sortie de BOW
tfidf_transformer = TfidfTransformer().ajuster(messages_arc)
messages_tfidf = tfidf_transformer.transformer(messages_arc)
#imprimer(messages_tfidf.shape)
#renvoyer le résultat des transformations
retourner messages_tfidf
6. Fonction pour imprimer les métriques de performance du modèle associé
#fonction qui prend la valeur de test y et la valeur prédite y et imprime les mesures de performance du modèle associées
def model_assessment(y_test,classe_prédite):
imprimer(« matrice de confusion »)
imprimer(confusion_matrice(y_test,classe_prédite))
imprimer('précision')
imprimer(score_précision(y_test,classe_prédite))
imprimer('précision')
imprimer(score_précision(y_test,classe_prédite,pos_label="pourriel"))
imprimer('rappeler')
imprimer(rappel_score(y_test,classe_prédite,pos_label="pourriel"))
imprimer('f-Score')
imprimer(f1_score(y_test,classe_prédite,pos_label="pourriel"))
imprimer('AUC')
imprimer(roc_auc_score(np.où(y_test=='spam',1,0),np.où(predicted_class=='spam',1,0)))
plt.matshow(confusion_matrice(y_test, classe_prédite), cmap=plt.cm.binaire, interpolation='le plus proche')
plt.titre(« matrice de confusion »)
plt.colorbar()
plt.ylabel('étiquette attendue')
plt.xlabel(« étiquette prévue »)
Commençons l'analyse comparative de quatre modèles différents pour obtenir l'algorithme le plus performant.
1.Modèle naïf de Bayes
Bayes ingénieux avec un sac de mots approche utilisant TF-IDFNaive Bayes est l'algorithme de tri le plus simple (rapide à former, utilisé régulièrement pour la détection de spam). c'est une méthode populaire (ligne de base) pour la catégorisation de texte, la question de juger des documents comme appartenant à une catégorie ou à l'opposé (comment spammer le légitime, sport ou politique, etc.) avec des fréquences de mots en raison des caractéristiques.
Extraction de caractéristiques à l'aide de BOW:
Fréquence TF-IDFTerm: la fréquence inverse du document utilise tous les jetons du jeu de données comme vocabulaire. La fréquence du terme et le nombre de documents au cours desquels le jeton est produit sont chargés de déterminer la fréquence inverse du document.. Ce que cela garantit, c'est que, si un jeton apparaît fréquemment au cours d'un document, ce jeton aura un TF élevé, mais si ce jeton apparaît fréquemment dans la plupart des documents, puis réduire l'IDF. Ces deux matrices TF et IDF pour un document sélectionné sont multipliées et normalisées pour faire le TF-IDF d'un document.
CODE
#créer et adapter le modèle NB modelNB = MultinomialNB() modelNB.fit(train_features,y_train) #transformer les fonctionnalités de test pour tester les performances du modèle test_features=caractéristiques_transformer(mail_test) #Prévisions du N.-B. predicted_class_NB=modelNB.predict(test_caractéristiques) #évaluer le N.-B. modèle_évaluation(y_test,prédit_classe_NB)
2.Modèle d'arbre de décision
Les arbres de décision sont utilisés pour la classification et la régression. La théorie pourrait être une mesure pour définir ce degré de désorganisation au cours d'un système appelé Entropie. Le facteur d'entropie varie d'un échantillon à l'autre. L'entropie est nulle pour l'échantillon homogène, et pour l'échantillon de dividendes égaux, l'entropie est 1. Choisissez la division qui a une entropie minimale par rapport au nœud principal et aux autres divisions. Plus l'entropie est petite, plus grand.
CODE
#créer et ajuster un modèle d'arbre model_tree=DecisionTreeClassifier() arbre_modèle.fit(train_features,y_train) #exécuter le modèle sur des métriques de test et d'impression predicted_class_tree=model_tree.predict(test_caractéristiques) modèle_évaluation(y_test,arbre_classe_prédite)
3. Machine à vecteur de soutien
Les défis de classification et de régression fonctionnent parfaitement pour cet algorithme d'apprentissage automatique supervisé populaire. (SVM). Cependant, il est principalement utilisé dans les problèmes de classification. Quand on travaille avec cet algorithme, dans l'espace à n dimensions, nous allons tracer chaque élément de données dans une certaine mesure, de sorte que la valeur de chaque caractéristique est la valeur d'une coordonnée sélectionnée. Support Vector Machine pourrait même être une frontière qui sépare mieux les 2 cours (hyperplan / ligne).
CODE
#créer et adapter le modèle SVM model_svm=SVC() model_svm.ajuster(train_features,y_train) #exécuter le modèle sur des métriques de test et d'impression prédit_classe_svm=model_svm.prédire(test_caractéristiques) modèle_évaluation(y_test,prédit_classe_svm)
4. Forêt aléatoire
La forêt aléatoire est comme un algorithme d'amorçage avec un modèle d'arbre d'appels (CHARIOT). La prédiction du dernier mot pourrait être une fonction de chaque prédiction. Cette prédiction finale peut simplement être la moyenne de toutes les prédictions. La forêt aléatoire fournit des prédictions beaucoup plus précises lorsqu'elle est placée à côté de modèles CART simples / CHAID ou régression dans de nombreux scénarios. Ces cas ont généralement un grand nombre de variables prédictives et une taille d'échantillon énorme.. C'est souvent parce qu'il capture la variance de plusieurs variables d'entrée dans un temps uniforme et permet à un grand nombre d'observations de participer à la prédiction..
CODE
de sklearn.ensemble importer RandomForestClassifier #créer et ajuster le modèle model_rf=RandomForestClassifier(n_estimateurs=20,critère='entropie') model_rf.ajuster(train_features,y_train) #exécuter le modèle sur des métriques de test et d'impression prédit_class_rf=model_rf.prédire(test_caractéristiques) modèle_évaluation(y_test,prédit_class_rf)
COMPARAISON:-
En voyant la sortie du 4 Des modèles, vous pouvez facilement comparer et trouver sa précision. D'après l'explication ci-dessus, l'ordre décroissant de précision est représenté par:
PRÉCISION DU MODÈLE
FORÊT ALÉATOIRE 0.77846
BAIES NAIVES 0,75076
ARBRE DE DÉCISION MODÈLE 0.65538
MACHINE À VECTEUR DE SOUTIEN 0.62153
RÉSULTATS
Les résultats sont très clairs : Random Forest est la méthode la plus précise pour détecter les spams.. La raison en est sa grande capacité de détour pour trouver la meilleure fonctionnalité en utilisant son caractère aléatoire.. Le modèle qui ne peut pas être utilisé pour une telle détection de spam est SVM. La raison en est sa petite expansion. SVM peut ne pas avoir la capacité de gérer de grandes quantités de données.
CONCLUSION
Cet article vous aidera à mettre en œuvre un projet de détection de spam à l'aide du deep learning. Ceci est largement basé sur une analyse comparative de quatre modèles différents. Restez à l'écoute d'Analytics Vidya pour les articles à venir. Vous pouvez l'utiliser comme référence. N'hésitez pas à mettre vos contributions dans la chatbox ci-dessous. Vous pouvez également me pinger sur LinkedIn à https://www.linkedin.com/in/shivani-sharma-aba6141b6/
Les médias présentés dans cet article ne sont pas la propriété de DataPeaker et sont utilisés à la discrétion de l'auteur.
