In fast jeder E-Mail- oder Messaging-Plattform gibt es einen Spam-Filter. Der Filter untersucht jede E-Mail oder Nachricht, sobald sie ankommt, und klassifiziert sie entweder als Spam oder Ham. Ihr Posteingang zeigt diejenigen an, die unter Schinken fallen. Die Nachrichten, die unter Spam fallen, werden abgelehnt oder separat angezeigt.
Sie können Ihren eigenen Spamfilter erstellen, indem Sie NLTK, Regex und Scikit-Learn als Hauptbibliotheken verwenden. Sie benötigen außerdem einen Datensatz, um Ihr Modell zu trainieren.
Ihren Datensatz verstehen
„Spam Classification for Basic NLP“ ist frei verfügbar Kaggle-Datensatz. Es enthält eine Mischung aus Spam- und Ham-Raw-Mail-Nachrichten. Es hat 5.796 Zeilen und 3 Spalten.
Der KATEGORIE Spalte gibt an, ob es sich bei einer Nachricht um Spam oder Ham handelt. Nummer eins steht für Spam, während Null für Ham steht. Der
NACHRICHT Spalte enthält die eigentliche Roh-Mail. Der DATEINAMEN Kategorie ist eine eindeutige Nachrichtenkennung.Vorbereiten Ihrer Umgebung
Um mitzumachen, benötigen Sie eine Grundverständnis von Python und maschinelles Lernen. Sie sollten auch gerne damit arbeiten Google Colab oder Jupyter Notebook.
Navigieren Sie für Jupyter Notebook zu dem Ordner, in dem sich das Projekt befinden soll. Erstellen Sie eine neue virtuelle Umgebung und führen Sie das Jupyter Notebook aus diesem Ordner aus. Google Colab benötigt diesen Schritt nicht. Erstellen Sie ein neues Notizbuch in Google Colab oder Jupyter Notebook.
Der vollständige Quellcode und der Datensatz sind verfügbar in a GitHub-Repository.
Führen Sie den folgenden magischen Befehl aus, um die erforderlichen Bibliotheken zu installieren.
!pip installiere nltk scikit-learn regex numpy pandasDu wirst benutzen:
- NLTK für Verarbeitung natürlicher Sprache (NLP).
- scikit-learn zum Erstellen des Modells für maschinelles Lernen.
- regex für die Arbeit mit regulären Ausdrücken.
- NumPy für die Arbeit mit Arrays.
- Pandas, um Ihren Datensatz zu manipulieren.
Bibliotheken importieren
Importieren Sie die Bibliotheken, die Sie in Ihrer Umgebung installiert haben. Importieren Sie die Regex-Bibliothek als re und scikit-learn als sklearn.
importieren Pandas als pd
importieren taub als np
importieren nltk
aus nltk.stem importieren WordNetLemmatizer
aus nltk.corpus importieren Stoppwörter
importieren Betreff
aus sklearn.model_selection importieren train_test_split
aus sklearn.metrics importieren Klassifizierung_Bericht
aus sklearn.feature_extraction.text importieren CountVectorizer
aus sklearn.feature_extraction.text importieren TfidfVectorizer
Sie verwenden WordNetLemmatizer und Stopwords-Module von NLTK, um die Rohnachrichten im Dataset vorzuverarbeiten. Während der Modellerstellung verwenden Sie importierte sklearn-Module.
Vorverarbeitung der Daten
Rufen Sie die Funktion pandas read_csv auf, um das Dataset zu laden. Stellen Sie sicher, dass Sie das Dataset im selben Verzeichnis wie Ihr Projekt speichern. Zeigen Sie die ersten fünf Zeilen des Datasets an, um eine visuelle Darstellung des Datasets zu erhalten.
df = pd.read_csv ('/content/Spam E-Mail-Rohtext für NLP.csv')
df.head()Löschen Sie die Spalte FILE_NAME des Datasets. Es ist keine nützliche Funktion für die Spam-Klassifizierung.
df.drop('DATEINAMEN', Achse=1, anstelle =WAHR)Überprüfen Sie die Anzahl der Ham- und Spam-Mails im Datensatz. Auf diese Weise können Sie später bestimmen, wie die Daten für Modelltraining und -tests aufgeteilt werden.
df. CATEGORY.value_counts()Laden Sie die Korpus-Stoppwörter aus der NLTK-Bibliothek herunter. Stoppwörter sind eine Reihe häufig vorkommender Wörter. Die Vorverarbeitung entfernt sie aus Nachrichten. Laden Sie die englischen Stoppwörter und speichern Sie sie in einer Stoppwortvariablen.
nltk.download('Stoppwörter')
stopword = nltk.corpus.stopwords.words('Englisch')Laden Sie das offene mehrsprachige WordNet herunter. Es ist eine lexikalische Datenbank englischer Wörter und ihrer semantischen Bedeutung.
nltk.download('omw-1.4')Laden Sie das Wordnet-Korpus herunter. Sie werden es zur Textklassifizierung verwenden. Instanziieren Sie ein WordNetLemmatizer()-Objekt. Sie werden das Objekt während der Lemmatisierung verwenden. Lemmatisierung ist eine Technik, die im NLP verwendet wird, um Ableitungsformen von Wörtern auf ihre Wörterbuchbedeutung zu reduzieren.
Zum Beispiel: Wenn Sie das Wort „Katzen“ reduzieren, erhalten Sie „Katze“. Ein Wort nach der Lemmatisierung wird zu einem Lemma.
nltk.download('wordnet')
Lemmatizer = WordNetLemmatizer()Erstellen Sie eine leere Liste, in der Sie die vorverarbeiteten Nachrichten speichern.
Korpus=[]Erstellen Sie eine for-Schleife, um jede Nachricht in der MESSAGE-Spalte des Datensatzes zu verarbeiten. Entfernen Sie alle nicht alphanumerischen Zeichen. Konvertieren Sie die Nachricht in Kleinbuchstaben. Teilen Sie den Text in Wörter auf. Entfernen Sie die Stoppwörter und lemmatisieren Sie die Wörter. Wandeln Sie die Wörter wieder in Sätze um. Hängen Sie die vorverarbeitete Nachricht an die Korpusliste an.
für ich In Bereich (len (df)):
# alle nicht alphanumerischen Zeichen entfernen
Nachricht = re.sub('[^a-zA-Z0-9]', ' ', df['NACHRICHT'][ich])# Konvertieren der Nachricht in Kleinbuchstaben
Nachricht = Nachricht.lower()# Aufteilen des Satzes in Wörter zur Lemmatisierung
Nachricht = Nachricht.split()# Stoppwörter entfernen und lemmatisieren
Nachricht = [lemmatizer.lemmatize (Wort) für Wort In Nachricht
Wenn Wort nichtIn set (stopwords.words('Englisch'))]# Die Wörter wieder in Sätze umwandeln
Nachricht = ' '.join (Nachricht)
# Hinzufügen der vorverarbeiteten Nachricht zur Korpusliste
corpus.append (Nachricht)
Diese Schleife dauert etwa fünf Minuten. Der Schritt zum Lemmatisieren und Entfernen von Stoppwörtern nimmt die meiste Zeit in Anspruch. Sie haben nun Ihre Daten vorverarbeitet.
Feature Engineering unter Verwendung des Bag-of-Words-Modells vs. TF-IDF-Technik
Feature-Engineering ist der Prozess der Umwandlung von Rohdaten-Features in neue Features, die für Machine-Learning-Modelle geeignet sind.
Bag-of-Words-Modell
Das Bag-of-Words-Modell stellt Textdaten als eine Häufigkeitsverteilung von Wörtern dar, die in dem Dokument vorhanden sind. So oft kommt ein Wort in einem Dokument vor.
Verwenden Sie die CountVectorizer-Klasse von scikit-learn, um die Textdaten in numerische Vektoren umzuwandeln. Passen Sie den Korpus der vorverarbeiteten Nachrichten an und transformieren Sie den Korpus in eine dünnbesetzte Matrix.
# Nehmen Sie die 2500 besten Funktionen
cv = CountVectorizer (max_features=2500, ngram_range=(1,3))
X = cv.fit_transform (corpus).toarray()
y = df['KATEGORIE']Teilen Sie die transformierten Daten in Trainings- und Testsätze auf. Verwenden Sie zwanzig Prozent der Daten für Tests und achtzig Prozent für Schulungen.
x_train, x_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=1, Schichtung=y)Das Bag-of-Words-Modell klassifiziert die Nachrichten im Datensatz korrekt. Aber wird nicht gut bei der Klassifizierung Ihrer eigenen Botschaften abschneiden. Es berücksichtigt nicht die semantische Bedeutung der Nachrichten. Verwenden Sie diese Technik, um nur die Nachrichten im Dataset zu klassifizieren.
TF-IDF-Technik
Der Begriff Frequency-Inverse Document Frequency (TF-IDF) funktioniert, indem er Wörtern in einem Dokument Gewichtungen zuweist, je nachdem, wie häufig sie vorkommen. TF-IDF gibt Wörtern, die häufig in einem Dokument vorkommen, aber im Korpus selten vorkommen, ein höheres Gewicht. Dadurch können maschinelle Lernalgorithmen die Bedeutung des Textes besser verstehen.
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, random_state=1, Schichtung=y)
Verwenden Sie TF-IDF, um semantische Bedeutung aus den Nachrichten zu extrahieren und Ihre eigenen Nachrichten zu klassifizieren.
Erstellen und Trainieren Ihres Modells
Beginnen Sie mit dem Erstellen und Initialisieren eines Naive-Bayes-Modells mithilfe der Klasse scikit-learn MultinomialNB.
Modell = MultinomialNB()Passen Sie die Trainingsdaten an, sodass das Modell mit dem Trainingssatz trainieren kann:
model.fit (x_Zug, y_Zug)Treffen Sie dann mithilfe der Vorhersagemethode Vorhersagen zu den Trainings- und Testdatensätzen.
train_pred = model.predict (x_train)
test_pred = model.predict (x_test)Diese Vorhersagen helfen Ihnen bei der Bewertung Ihres Modells.
Modellbewertung
Bewerten Sie die Leistung Ihres Modells mit der Classification_report-Funktion von scikit-learn. Übergeben Sie die Trainingssatzvorhersagen und die tatsächlichen Trainingssatzbezeichnungen als Eingabe. Machen Sie dasselbe für das Testset.
print (classification_report (train_pred, y_train))
print (classification_report (test_pred, y_test))Je höher die Präzision, der Abruf und die Genauigkeit für beide Klassen sind, desto besser ist das Modell.
Ergebnisse der Klassifizierung Ihrer eigenen Nachrichten
Wandeln Sie die Nachricht mithilfe der TF-IDF-Technik in einen Vektor um. Verwenden Sie das Modell, um vorherzusagen, ob es sich bei der Nachricht um Spam oder Ham handelt, und zeigen Sie diese Vorhersage dann auf dem Bildschirm an.
drucken('Prognose...')Nachricht = ["Sie haben 10000 Dollar gewonnen, geben Sie bitte Ihr Konto an
Details, damit wir das Geld überweisen können"]
message_vector = tf.transform (Nachricht)
Kategorie = model.predict (Nachrichtenvektor)
drucken("Die Botschaft ist", "Spam"Wenn Kategorie == 1anders"Kein spam")
Ersetzen Sie die Nachricht durch Ihre Selbst.
Die Ausgabe ist wie folgt:
Das Modell kann neue ungesehene Nachrichten als Spam oder Ham klassifizieren.
Die Herausforderung bei der Spam-Klassifizierung in Anwendungen
Die größte Herausforderung bei der Spam-Klassifizierung in Anwendungen ist die falsche Klassifizierung von Nachrichten. Machine-Learning-Modelle sind nicht immer korrekt. Sie können Spam als Ham klassifizieren und umgekehrt. Im Falle der Einstufung von Ham als Spam kann ein Programm E-Mails aus dem Posteingang des Benutzers entfernen, wodurch ihm wichtige Nachrichten entgehen.
