Esiste un filtro antispam in quasi tutte le piattaforme di posta elettronica o messaggistica. Il filtro esamina ogni posta o messaggio non appena arriva e lo classifica come spam o ham. La tua casella di posta mostra quelli che rientrano in ham. Rifiuta o visualizza separatamente i messaggi che rientrano nello spam.
Puoi creare il tuo filtro antispam utilizzando NLTK, regex e scikit-learn come librerie principali. Avrai anche bisogno di un set di dati per addestrare il tuo modello.
Comprensione del set di dati
"Classificazione dello spam per la PNL di base" è disponibile gratuitamente Set di dati Kaggle. Contiene un misto di spam e messaggi di posta non elaborati. Ha 5.796 righe e 3 colonne.
IL CATEGORIA colonna indica se un messaggio è spam o ham. Il numero uno rappresenta lo spam mentre lo zero rappresenta il prosciutto. IL
MESSAGGIO colonna contiene la posta non elaborata effettiva. IL NOME DEL FILE la categoria è un identificatore di messaggio univoco.Preparare il tuo ambiente
Per seguire, avrai bisogno di un file conoscenza di base di Python e apprendimento automatico. Dovresti anche sentirti a tuo agio nel lavorare con Google Colab o Notebook Jupyter.
Per Jupyter Notebook, vai alla cartella in cui vuoi che il progetto risieda. Crea un nuovo ambiente virtuale ed esegui Jupyter Notebook da questa cartella. Google Colab non ha bisogno di questo passaggio. Crea un nuovo taccuino in Google Colab o Jupyter Notebook.
Il codice sorgente completo e il set di dati sono disponibili in a Deposito GitHub.
Esegui il seguente comando magico per installare le librerie richieste.
!pip installa nltk scikit-learn regex numpy pandaUserai:
- NLTK per elaborazione del linguaggio naturale (PNL).
- scikit-learn per creare il modello di machine learning.
- regex per lavorare con le espressioni regolari.
- NumPy per lavorare con gli array.
- Panda per manipolare il tuo set di dati.
Importa librerie
Importa le librerie che hai installato nel tuo ambiente. Importa la libreria regex come re e scikit-learn come sklearn.
importare panda COME pd
importare intorpidito COME np
importare nltk
da nltk.stem importare WordNetLemmatizer
da nltk.corpus importare parole d'ordine
importare Rif
da sklearn.model_selection importare train_test_split
da sklearn.metrics importare rapporto_classificazione
da sklearn.feature_extraction.text importare CountVectorizer
da sklearn.feature_extraction.text importare Tfidf Vectorizer
Utilizzerai i moduli WordNetLemmatizer e stopwords di NLTK per preelaborare i messaggi non elaborati nel set di dati. Utilizzerai i moduli sklearn importati durante la creazione del modello.
Preelaborazione dei dati
Chiama la funzione pandas read_csv per caricare il set di dati. Assicurati di archiviare il set di dati nella stessa directory del progetto. Visualizza le prime cinque righe del set di dati per ottenere una visuale del set di dati.
df = pd.read_csv('/content/Spam Email testo non elaborato per NLP.csv')
df.head()Rilascia la colonna FILE_NAME del set di dati. Non è una funzione utile per la classificazione dello spam.
df.goccia('NOME DEL FILE', asse=1, al posto=VERO)Controlla il numero di messaggi ham e spam nel set di dati. Questo ti aiuterà in seguito a determinare come suddividere i dati per l'addestramento e il test del modello.
df. CATEGORIA.value_counts()Scarica le stopword del corpus dalla libreria NLTK. Le stopword sono un insieme di parole ricorrenti. La preelaborazione li rimuove dai messaggi. Carica le stopword inglesi e memorizzale in una variabile stopword.
nltk.download('parole non significative')
stopword = nltk.corpus.stopwords.words('inglese')Scarica il WordNet multilingue aperto. È un database lessicale di parole inglesi e dei loro significati semantici.
nltk.download('omw-1.4')Scarica il corpus wordnet. Lo userai per la classificazione del testo. Crea un'istanza di un oggetto WordNetLemmatizer(). Utilizzerai l'oggetto durante la lemmatizzazione. La lemmatizzazione è una tecnica utilizzata in PNL per ridurre le forme derivazionali delle parole al significato del loro dizionario.
Ad esempio: riducendo la parola "gatti" otterrai "gatto". Una parola dopo la lemmatizzazione diventa un lemma.
nltk.download('rete di parole')
lemmatizer = WordNetLemmatizer()Crea un elenco vuoto che utilizzerai per archiviare i messaggi preelaborati.
corpus=[]Crea un ciclo for per elaborare ogni messaggio nella colonna MESSAGE del set di dati. Rimuovi tutti i caratteri non alfanumerici. Converti il messaggio in minuscolo. Dividi il testo in parole. Rimuovi le stopword e lemmatizza le parole. Riconvertire le parole in frasi. Aggiungere il messaggio preelaborato all'elenco del corpus.
per io In intervallo (len (df)):
# rimuovendo tutti i caratteri non alfanumerici
messaggio = re.sub('[^a-zA-Z0-9]', ' ', df['MESSAGGIO'][io])# conversione del messaggio in minuscolo
messaggio = messaggio.inferiore()# dividendo la frase in parole per la lemmatizzazione
messaggio = messaggio.split()# rimozione di stopword e lemmatizzazione
messaggio = [lemmatizer.lemmatize (parola) per parola In Messaggio
Se parola nonIn imposta (parole non significative.parole('inglese'))]# Riconvertire le parole in frasi
messaggio = ' '.join (messaggio)
# Aggiunta del messaggio preelaborato all'elenco del corpus
corpus.append (messaggio)
L'esecuzione di questo ciclo richiederà circa cinque minuti. Il passaggio di lemmatizzazione e rimozione delle parole non significative richiede la maggior parte del tempo. Ora hai preelaborato i tuoi dati.
Ingegneria delle caratteristiche utilizzando il modello Bag-of-Words rispetto alla tecnica TF-IDF
L'ingegneria delle funzionalità è il processo di conversione delle funzionalità dei dati grezzi in nuove funzionalità adatte ai modelli di machine learning.
Modello Bag-of-Words
Il modello bag-of-words rappresenta i dati di testo come una distribuzione di frequenza delle parole presenti nel documento. Questo è semplicemente il numero di volte in cui una parola ricorre in un documento.
Utilizzare la classe CountVectorizer di scikit-learn per convertire i dati di testo in vettori numerici. Adatta il corpus di messaggi preelaborati e trasforma il corpus in una matrice sparsa.
# Prendi le migliori 2500 funzionalità
cv = CountVectorizer (max_features=2500, ngram_range=(1,3))
X = cv.fit_transform (corpus).toarray()
y = df['CATEGORIA']Dividi i dati trasformati in set di training e test. Usa il venti percento dei dati per i test e l'ottanta percento per la formazione.
x_train, x_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=1, stratifica=y)Il modello bag-of-words classificherà correttamente i messaggi nel set di dati. Ma non funzionerà bene nella classificazione dei tuoi messaggi. Non tiene conto del significato semantico dei messaggi. Per classificare solo i messaggi nel set di dati, utilizzare questa tecnica.
Tecnica TF-IDF
Il Term Frequency-Inverse Document Frequency (TF-IDF) funziona assegnando pesi alle parole in un documento in base alla frequenza con cui appaiono. TF-IDF fornisce parole che compaiono frequentemente in un documento ma sono rare nel corpus di maggior peso. Ciò consente agli algoritmi di apprendimento automatico di comprendere meglio il significato del testo.
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, stratifica=y)
Per estrarre il significato semantico dai messaggi e classificare i tuoi messaggi usa TF-IDF.
Creare e addestrare il tuo modello
Inizia creando e inizializzando un modello Naive Bayes usando la classe scikit-learn MultinomialNB.
modello = MultinomialNB()Adatta i dati di addestramento, consentendo al modello di addestrarsi sul set di addestramento:
model.fit (x_treno, y_treno)Quindi effettuare previsioni sui set di addestramento e test utilizzando il metodo predict.
train_pred = modello.predict (x_train)
test_pred = modello.predict (x_test)Queste previsioni ti aiuteranno a valutare il tuo modello.
Valutazione del modello
Valuta le prestazioni del tuo modello utilizzando la funzione di classificazione_report di scikit-learn. Passa le previsioni del set di allenamento e le etichette del set di allenamento effettivo come input. Fai lo stesso per il set di prova.
stampa (classificazione_report (treno_pred, y_treno))
print (rapporto_classificazione (test_pred, y_test))Maggiore è la precisione, il richiamo e l'accuratezza per entrambe le classi, migliore è il modello.
Risultati della classificazione dei propri messaggi
Trasforma il messaggio in un vettore utilizzando la tecnica TF-IDF. Utilizza il modello per prevedere se il messaggio è spam o ham, quindi visualizza tale previsione sullo schermo.
stampa('Prevedere...')messaggio = ["Hai vinto 10000 dollari, per favore fornisci il tuo account
dettagli, in modo che possiamo trasferire i soldi"]
message_vector = tf.transform (messaggio)
categoria = model.predict (vettore_messaggio)
stampa("Il messaggio è", "spam"Se categoria == 1altro"non spam")
Sostituisci il messaggio con il tuo.
L'output è il seguente:
Il modello può classificare i nuovi messaggi invisibili come spam o ham.
La sfida per la classificazione dello spam nelle applicazioni
La sfida principale per la classificazione dello spam nelle applicazioni è l'errata classificazione dei messaggi. I modelli di machine learning non sono sempre corretti. Possono classificare lo spam come ham e viceversa. Nel caso di classificazione di ham come spam, un programma può rimuovere la posta dalla posta in arrivo dell'utente, facendogli perdere messaggi importanti.
