Existe um filtro de spam em quase todas as plataformas de e-mail ou mensagens. O filtro examina cada e-mail ou mensagem à medida que chega e os classifica como spam ou ham. Sua caixa de entrada exibe aqueles que se enquadram em ham. Ele rejeita, ou exibe separadamente, as mensagens que se enquadram no spam.
Você pode criar seu próprio filtro de spam usando NLTK, regex e scikit-learn como bibliotecas principais. Você também precisará de um conjunto de dados para treinar seu modelo.
Compreendendo seu conjunto de dados
“Classificação de Spam para NLP Básico” é um Conjunto de dados do Kaggle. Ele contém uma mistura de spam e mensagens de e-mail não processadas. Tem 5.796 linhas e 3 colunas.
O CATEGORIA coluna indica se uma mensagem é spam ou ham. O número um representa spam enquanto o zero representa presunto. O MENSAGEM A coluna contém o e-mail bruto real. O NOME DO ARQUIVO categoria é um identificador de mensagem exclusivo.
Preparando seu ambiente
Para acompanhar, você precisa ter um entendimento básico de Python e aprendizado de máquina. Você também deve se sentir confortável trabalhando com Google Colab ou Notebook Jupyter.
No Jupyter Notebook, navegue até a pasta em que deseja que o projeto resida. Crie um novo ambiente virtual e execute o Jupyter Notebook a partir desta pasta. O Google Colab não precisa dessa etapa. Crie um novo notebook no Google Colab ou Jupyter Notebook.
O código-fonte completo e o conjunto de dados estão disponíveis em um Repositório GitHub.
Execute o seguinte comando mágico para instalar as bibliotecas necessárias.
!pip install nltk scikit-learn regex numpy pandasVocê vai usar:
- NLTK para processamento de linguagem natural (PNL).
- scikit-learn para criar o modelo de aprendizado de máquina.
- regex para trabalhar com expressões regulares.
- NumPy para trabalhar com matrizes.
- Pandas para manipular seu conjunto de dados.
Bibliotecas de importação
Importe as bibliotecas instaladas em seu ambiente. Importe a biblioteca regex como re e scikit-learn como sklearn.
importar pandas como pd
importar entorpecido como np
importar nltk
de nltk.stem importar WordNetLemmatizer
de nltk.corpus importar palavras irrelevantes
importar ré
de sklearn.model_selection importar train_test_split
de sklearn.metrics importar relatório_classificação
de sklearn.feature_extraction.text importar CountVectorizer
de sklearn.feature_extraction.text importar TfidfVectorizerName
Você usará os módulos WordNetLemmatizer e stopwords do NLTK para pré-processar as mensagens brutas no conjunto de dados. Você usará módulos sklearn importados durante a construção do modelo.
Pré-processando os dados
Chame a função pandas read_csv para carregar o conjunto de dados. Certifique-se de armazenar o conjunto de dados no mesmo diretório do seu projeto. Exiba as cinco primeiras linhas do conjunto de dados para obter um visual do conjunto de dados.
df = pd.read_csv('/content/Spam Email texto bruto para NLP.csv')
df.head()Elimine a coluna FILE_NAME do conjunto de dados. Não é um recurso útil para classificação de spam.
df.drop('NOME DO ARQUIVO', eixo=1, local =Verdadeiro)Verifique a contagem de spam e spam no conjunto de dados. Posteriormente, isso ajudará você a determinar como dividir os dados para treinamento e teste de modelo.
df. CATEGORY.value_counts()Baixe as stopwords do corpus da biblioteca NLTK. Stopwords são um conjunto de palavras que ocorrem comumente. O pré-processamento os remove das mensagens. Carregue as stopwords em inglês e armazene-as em uma variável de stopword.
nltk.download('palavras de parada')
stopword = nltk.corpus.stopwords.words('inglês')Baixe o WordNet multilíngue aberto. É um banco de dados lexical de palavras em inglês e seus significados semânticos.
nltk.download('omw-1.4')Baixe o corpus wordnet. Você o usará para classificação de texto. Crie uma instância de um objeto WordNetLemmatizer(). Você usará o objeto durante a lematização. Lematização é uma técnica usada em PNL para reduzir formas derivacionais de palavras ao seu significado de dicionário.
Por exemplo: Reduzir a palavra “gatos” resultará em “gato”. Uma palavra após a lematização torna-se um lema.
nltk.download('rede de palavras')
lemmatizer = WordNetLemmatizer()Crie uma lista vazia que você usará para armazenar as mensagens pré-processadas.
corpus=[]Crie um loop for para processar todas as mensagens na coluna MESSAGE do conjunto de dados. Remova todos os caracteres não alfanuméricos. Converta a mensagem para letras minúsculas. Divida o texto em palavras. Remova as stopwords e lemmatize as palavras. Converta as palavras de volta em frases. Acrescente a mensagem pré-processada à lista do corpus.
para eu em intervalo (len (df)):
# removendo todos os caracteres não alfanuméricos
mensagem = re.sub('[^a-zA-Z0-9]', ' ', df['MENSAGEM'][eu])# convertendo a mensagem para letras minúsculas
message = message.lower()# dividindo a frase em palavras para lematização
mensagem = mensagem.split()# removendo stopwords e lemmatizando
message = [lemmatizer.lemmatize (palavra) para palavra em mensagem
se palavra nãoem definir (palavras de parada.palavras('inglês'))]# Convertendo as palavras de volta em frases
mensagem = ' '.join (mensagem)
# Adicionando a mensagem pré-processada à lista do corpus
corpus.append (mensagem)
Esse loop levará cerca de cinco minutos para ser executado. A etapa de lematização e remoção de stopwords leva a maior parte do tempo. Agora você pré-processou seus dados.
Engenharia de recursos usando o modelo Bag-of-Words versus técnica TF-IDF
A engenharia de recursos é o processo de conversão de recursos de dados brutos em novos recursos adequados para modelos de aprendizado de máquina.
Modelo Saco de Palavras
O modelo bag-of-words representa dados de texto como uma distribuição de frequência de palavras presentes no documento. Isso é simplesmente como o número de vezes que uma palavra ocorre em um documento.
Use a classe CountVectorizer do scikit-learn para converter os dados de texto em vetores numéricos. Ajustar o corpus de mensagens pré-processadas e transformar o corpus em uma matriz esparsa.
# Pegue os 2500 principais recursos
cv = CountVectorizer (max_features=2500, ngram_range=(1,3))
X = cv.fit_transform (corpus).toarray()
y = df['CATEGORIA']Divida os dados transformados em conjuntos de treinamento e teste. Use vinte por cento dos dados para teste e oitenta por cento para treinamento.
x_train, x_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=1, estratificar=y)O modelo bag-of-words classificará as mensagens no conjunto de dados corretamente. Mas não terá um bom desempenho na classificação de suas próprias mensagens. Não leva em consideração o significado semântico das mensagens. Para classificar apenas as mensagens no conjunto de dados, use esta técnica.
Técnica TF-IDF
O Term Frequency-Inverse Document Frequency (TF-IDF) funciona atribuindo pesos às palavras em um documento com base na frequência com que aparecem. O TF-IDF dá maior peso às palavras que aparecem com frequência em um documento, mas são raras no corpus. Isso permite que os algoritmos de aprendizado de máquina entendam melhor o significado do texto.
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, estratificar=y)
Para extrair o significado semântico das mensagens e classificar suas próprias mensagens, use TF-IDF.
Criando e treinando seu modelo
Comece criando e inicializando um modelo Naive Bayes usando a classe scikit-learn MultinomialNB.
modelo = MultinomialNB()Ajuste os dados de treinamento, permitindo que o modelo treine no conjunto de treinamento:
model.fit (x_train, y_train)Em seguida, faça previsões nos conjuntos de treinamento e teste usando o método de previsão.
train_pred = model.predict (x_train)
test_pred = model.predict (x_test)Essas previsões ajudarão você a avaliar seu modelo.
Avaliação do modelo
Avalie o desempenho do seu modelo usando a função research_report do scikit-learn. Passe as previsões do conjunto de treinamento e os rótulos do conjunto de treinamento real como entrada. Faça o mesmo para o conjunto de teste.
imprimir (classification_report (train_pred, y_train))
imprimir (classification_report (test_pred, y_test))Quanto maior a precisão, recall e exatidão para ambas as classes, melhor o modelo.
Resultados da classificação de suas próprias mensagens
Transforme a mensagem em um vetor usando a técnica TF-IDF. Use o modelo para prever se a mensagem é spam ou presunto e exiba essa previsão na tela.
imprimir('Prevendo...')mensagem = ["Você ganhou 10.000 dólares, forneça sua conta
detalhes, para que possamos transferir o dinheiro"]
message_vector = tf.transform (mensagem)
categoria = model.predict (message_vector)
imprimir("A mensagem é", "Spam"se categoria == 1outro"não é spam")
Substitua a mensagem com seus próprios.
A saída é a seguinte:
O modelo pode classificar novas mensagens não vistas como spam ou ham.
O desafio da classificação de spam em aplicativos
O principal desafio enfrentado pela classificação de spam em aplicativos é a classificação incorreta de mensagens. Os modelos de aprendizado de máquina nem sempre estão corretos. Eles podem classificar spam como ham e vice-versa. No caso de classificar o ham como spam, um programa pode remover o e-mail da caixa de entrada do usuário, fazendo com que ele perca mensagens importantes.
