Lesere som deg er med på å støtte MUO. Når du foretar et kjøp ved å bruke lenker på nettstedet vårt, kan vi tjene en tilknyttet provisjon. Les mer.

Det er et spamfilter i nesten alle e-post- eller meldingsplattformer. Filteret undersøker hver e-post eller melding når den ankommer og klassifiserer den som enten spam eller skinke. Innboksen din viser de som faller inn under skinke. Den avviser, eller viser separat, meldingene som faller inn under spam.

Du kan lage ditt eget spamfilter ved å bruke NLTK, regex og scikit-learn som hovedbibliotek. Du trenger også et datasett for å trene modellen din.

Forstå datasettet ditt

"Spam Classification for Basic NLP" er en fritt tilgjengelig Kaggle datasett. Den inneholder en blanding av spam og ham raw e-postmeldinger. Den har 5 796 rader og 3 kolonner.

De KATEGORI kolonnen indikerer om en melding er spam eller skinke. Nummer én representerer spam mens null representerer skinke. De BESKJED kolonnen inneholder den faktiske råposten. De FILNAVN kategori er en unik meldingsidentifikator.

instagram viewer

Forberede miljøet ditt

For å følge med må du ha en grunnleggende forståelse av Python og maskinlæring. Du bør også være komfortabel med å jobbe med Google Colab eller Jupyter Notebook.

For Jupyter Notebook, naviger til mappen du vil at prosjektet skal ligge i. Opprett et nytt virtuelt miljø og kjør Jupyter Notebook fra denne mappen. Google Colab trenger ikke dette trinnet. Opprett en ny notatbok i enten Google Colab eller Jupyter Notebook.

Den fullstendige kildekoden og datasettet er tilgjengelig i en GitHub-depot.

Kjør følgende magiske kommando for å installere de nødvendige bibliotekene.

!pip installer nltk scikit-learn regex numpy pandas

Du vil bruke:

  • NLTK for naturlig språkbehandling (NLP).
  • scikit-learn for å lage maskinlæringsmodellen.
  • regex for å jobbe med regulære uttrykk.
  • NumPy for arbeid med matriser.
  • Pandaer for å manipulere datasettet ditt.

Importer biblioteker

Importer bibliotekene du installerte i miljøet ditt. Importer regex-biblioteket som re og scikit-learn som sklearn.

import pandaer som pd
import nusset som np
import nltk 
fra nltk.stem import WordNetLemmatizer
fra nltk.korpus import stoppord
import re
fra sklearn.model_selection import train_test_split
fra sklearn.metrics import klassifiseringsrapport 
fra sklearn.feature_extraction.text import CountVectorizer
fra sklearn.feature_extraction.text import TfidfVectorizer

Du vil bruke WordNetLemmatizer og stoppord-moduler fra NLTK for å forhåndsbehandle råmeldingene i datasettet. Du vil bruke importerte sklearn-moduler under modellbygging.

Forbehandling av data

Kall pandas read_csv-funksjonen for å laste datasettet. Sørg for at du lagrer datasettet i samme katalog som prosjektet ditt. Vis de første fem radene i datasettet for å få et bilde av datasettet.

df = pd.read_csv('/content/Spam E-post råtekst for NLP.csv')
df.head()

Slipp FILE_NAME-kolonnen i datasettet. Det er ikke en nyttig funksjon for spamklassifisering.

df.drop('FILNAVN', akse=1, på plass=ekte)

Sjekk for tellingen av skinke og søppelpost i datasettet. Dette vil senere hjelpe deg med å finne ut hvordan du deler dataene for modelltrening og testing.

df. CATEGORY.value_counts()

Last ned korpusstoppordene fra NLTK-biblioteket. Stoppord er et sett med ord som ofte forekommer. Forhåndsbehandling fjerner dem fra meldinger. Last de engelske stoppordene og lagre dem i en stoppordvariabel.

nltk.nedlasting('stoppord')
stopword = nltk.corpus.stopwords.words('Engelsk')

Last ned det åpne flerspråklige WordNet. Det er en leksikalsk database med engelske ord og deres semantiske betydninger.

nltk.nedlasting('omw-1.4')

Last ned wordnet-korpus. Du vil bruke den til tekstklassifisering. Instantier et WordNetLemmatizer()-objekt. Du vil bruke objektet under lemmatisering. Lemmatisering er en teknikk som brukes i NLP for å redusere avledningsformer av ord til deres ordbokbetydning.

For eksempel: Å redusere ordet "katter" vil gi deg "katt". Et ord etter lemmatisering blir et lemma.

nltk.nedlasting('wordnet')
lemmatizer = WordNetLemmatizer()

Lag en tom liste som du vil bruke til å lagre de forhåndsbehandlede meldingene.

korpus=[]

Opprett en for-løkke for å behandle hver melding i MESSAGE-kolonnen i datasettet. Fjern alle ikke-alfanumeriske tegn. Konverter meldingen til små bokstaver. Del teksten i ord. Fjern stoppordene og lemmatiser ordene. Gjør ordene tilbake til setninger. Legg til den forhåndsbehandlede meldingen i korpuslisten.

til Jeg i område (len (df)):
# fjerner alle ikke-alfanumeriske tegn
 melding = re.sub('[^a-zA-Z0-9]', ' ', df['BESKJED'][Jeg]) 
# konverterer meldingen til små bokstaver
 melding = message.lower() 


# dele opp setningen i ord for lemmatisering 
 melding = melding.split() 


# fjerning av stoppord og lemmatisering 
 melding = [lemmatizer.lemmatize (ord) til ord i beskjed
hvis ord ikkei sett (stoppord.ord('Engelsk'))] 


# Konvertering av ordene tilbake til setninger
 melding = ' '.join (melding) 
# Legge til den forhåndsbehandlede meldingen til korpuslisten 
 corpus.append (melding)

Denne sløyfen vil ta rundt fem minutter å kjøre. Det å lemmatisere og fjerne stoppord-trinnet tar mesteparten av tiden. Du har nå forhåndsbehandlet dataene dine.

Funksjonsteknikk ved å bruke Bag-of-Words-modellen vs TF-IDF-teknikk

Funksjonsteknikk er prosessen med å konvertere rådatafunksjoner til nye funksjoner egnet for maskinlæringsmodeller.

Bag-of-Words-modell

Bag-of-words-modellen representerer tekstdata som en frekvensfordeling av ord som finnes i dokumentet. Dette er ganske enkelt hvordan antall ganger et ord forekommer i et dokument.

Bruk CountVectorizer-klassen fra scikit-learn for å konvertere tekstdataene til numeriske vektorer. Tilpass korpuset av forhåndsbehandlede meldinger og transformer korpuset til en sparsom matrise.

# Ta topp 2500 funksjoner 
cv = CountVectorizer (max_features=2500, ngram_range=(1,3)) 
X = cv.fit_transform (corpus).toarray()
y = df['KATEGORI']

Del de transformerte dataene inn i trenings- og testsett. Bruk tjue prosent av dataene til testing og åtti prosent til trening.

x_train, x_test, y_train, y_test = train_test_split(
 X, y, test_size=0.20, random_state=1, stratify=y)

Bag-of-words-modellen vil klassifisere meldingene i datasettet riktig. Men vil ikke prestere godt i å klassifisere dine egne meldinger. Den tar ikke hensyn til den semantiske betydningen av meldingene. For kun å klassifisere meldingene i datasettet, bruk denne teknikken.

TF-IDF-teknikk

Term Frequency-Inverse Document Frequency (TF-IDF) fungerer ved å tildele vekter til ord i et dokument basert på hvor ofte de vises. TF-IDF gir ord som forekommer ofte i et dokument, men som er sjeldne i korpuset høyere vekt. Dette lar maskinlæringsalgoritmer bedre forstå betydningen av teksten.

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, stratify=y)

For å trekke ut semantisk mening fra meldingene og klassifisere dine egne meldinger, bruk TF-IDF.

Lage og trene modellen din

Start med å lage og initialisere en Naiv Bayes-modell ved å bruke scikit-learn MultinomialNB-klassen.

modell = MultinomialNB()

Tilpass treningsdataene, slik at modellen kan trene på treningssettet:

model.fit (x_train, y_train)

Gjør deretter spådommer på trenings- og testsettene ved å bruke prediksjonsmetoden.

train_pred = model.predict (x_train)
test_pred = model.predict (x_test)

Disse spådommene vil hjelpe deg med å evaluere modellen din.

Modellvurdering

Evaluer ytelsen til modellen din ved å bruke funksjonen classification_report fra scikit-learn. Send treningssettets spådommer og de faktiske treningssettets etiketter som input. Gjør det samme for testsettet.

print (klassifiseringsrapport (train_pred, y_train))
print (klassifiseringsrapport (test_pred, y_test))

Jo høyere presisjon, gjenkalling og nøyaktighet for begge klasser, jo bedre er modellen.

Resultater av å klassifisere dine egne meldinger

Transformer meldingen til en vektor ved hjelp av TF-IDF-teknikken. Bruk modellen til å forutsi om meldingen er spam eller skinke, og vis deretter prediksjonen på skjermen.

skrive ut("Forutsi ...")
melding = ["Du vant 10 000 dollar, vennligst oppgi kontoen din 
 detaljer, slik at vi kan overføre pengene"]
meldingsvektor = tf.transform (melding)
kategori = model.predict (meldingsvektor)
skrive ut("Beskjeden er", "spam"hvis kategori == 1ellers"ikke spam")

Bytt ut meldingen med din egen.

Utgangen er som følger:

Modellen kan klassifisere nye usynlige meldinger som spam eller skinke.

Utfordringen mot spamklassifisering i applikasjoner

Hovedutfordringen for spamklassifisering i applikasjoner er feilklassifiseringen av meldinger. Maskinlæringsmodeller er ikke alltid riktige. De kan klassifisere spam som skinke og omvendt. I tilfelle av å klassifisere skinke som spam, kan et program fjerne e-post fra brukerens innboks, slik at de går glipp av viktige meldinger.