Detecção de spam | Aplicativos de PNL

Compartilhar no Facebook
Compartilhar no Twitter
Compartilhar no LinkedIn
Compartilhar no telegrama
Compartilhar no Whatsapp

Conteúdo

Este artigo foi publicado como parte do Data Science Blogathon

Este artigo tem como objetivo comparar quatro diferentes algoritmos de aprendizado profundo e aprendizado de máquina para construir um detector de spam e avaliar seu desempenho.. O conjunto de dados que usamos veio de uma amostra aleatória de assuntos e corpos de e-mail que continham spam e e-mails prejudiciais em várias proporções, que transformamos em slogans. A detecção de spam é um dos projetos de aprendizado profundo mais eficazes, mas também é um projeto em que as pessoas perdem a confiança para procurar o modelo mais simples para fins de precisão. Neste artigo, vamos detectar spam no e-mail usando quatro técnicas diferentes e compará-las para obter o modelo mais preciso.

0mbfbpcpujd-53v3h-5715053

Fonte

POR QUE DETECÇÃO DE SPAM?

Um e-mail se tornou um dos tipos de comunicação mais importantes. Sobre 2014, estima-se que haja 4,1 1 bilhão de contas de e-mail em todo o mundo, e ao redor 196 1 bilhão de e-mails são enviados dia após dia em todo o mundo. O spam é uma das principais ameaças apresentadas aos usuários de e-mail. Todos os fluxos de e-mail que foram spam em 2013 são as 69,6%. Portanto, a tecnologia de filtragem de spam eficaz é uma contribuição significativa para a sustentabilidade do ciberespaço e de nossa sociedade. Uma vez que a importância do e-mail não é menor do que a de sua conta bancária contendo 1Cr., Protegê-lo contra spam ou fraude também é obrigatório.

Preparação de dados

Para preparar os dados, nós seguimos os passos abaixo:

1. Baixe e-mails de spam e spam por meio do Google takeaway como um arquivo de caixa.

2. Leia arquivos mbox em listas usando o pacote 'caixa de correio'. Cada item da lista continha um e-mail individual. Na primeira iteração, nós incluímos 1000 E-mails de radioamadorismo e 400 e-mails de spam (testamos proporções diferentes após a primeira iteração).

3. Descompactou cada e-mail e concatenou seu assunto e corpo. Decidimos incluir o assunto do e-mail em nossa análise também porque ele também é um grande indicador de se um e-mail é spam ou spam..

4. Listas convertidas em quadros de dados, juntou-se a frames de dados de spam e ham, e misturei o quadro de dados resultante.

5. Divida o quadro de dados em quadros de dados de teste e fluxo. Os dados de teste foram 33% do conjunto de dados original.

6. Divida o texto do e-mail em slogans e aplique a transformação TF-IDF usando CountVectorizer seguido pelo transformador TF-IDF.

7. Quatro modelos foram treinados usando os dados de treinamento:

  • Bayes ingenuo
  • Árvores de decisão
  • Máquina de vetores de suporte (SVM)
  • Floresta aleatória

8. Usando os modelos treinados, rótulo de e-mail previsto para conjunto de dados de teste. Quatro métricas foram calculadas para medir o desempenho dos modelos como Precisão, Precisão, Recuperação, Pontuação F, AUC.

CÓDIGO

1.Importar as bibliotecas

#importe todas as bibliotecas necessárias
importar caixa de correio
% matplotlib inline
import matplotlib.pyplot as plt
importar csv
from textblob import TextBlob
importar pandas
importar sklearn
#import cPickle
importar numpy como np
de sklearn.feature_extraction.text import CountVectorizer, TfidfTransformer
de sklearn.naive_bayes import MultinomialNB
de sklearn.svm import SVC, LinearSVC
de sklearn.metrics importar classificação_report, f1_score, precisão_pontuação, confusão_matriz
de sklearn.pipeline import Pipeline
de sklearn.grid_search import GridSearchCV
de sklearn.cross_validation import StratifiedKFold, cross_val_score, train_test_split
de sklearn.tree import DecisionTreeClassifier
de sklearn.learning_curve import learning_curve
#import metrics library
de sklearn.metrics import confused_matrix
de sklearn.metrics import precision_score
de sklearn.metrics import recall_score
de sklearn.metrics import f1_score
de sklearn.metrics import roc_auc_score

2.Função para obter o texto do e-mail a partir do corpo do e-mail

def getmailtext(mensagem): #obtendo texto simples 'corpo do e-mail'
    corpo = nenhum
    #verifique se a mensagem de e-mail mbox tem várias partes
    if message.is_multipart():
        para parte em message.walk():
            if part.is_multipart():
                para subparte em part.walk():
                    if subpart.get_content_type() == 'texto / simples':
                        body = subpart.get_payload(decode = True)
            elif part.get_content_type() == 'texto / simples':
                body = part.get_payload(decode = True)
    #se a mensagem tiver apenas uma parte
    elif message.get_content_type() == 'texto / simples':
        body = message.get_payload(decode = True)
    #retornar o texto do e-mail que concatena o assunto e o corpo do e-mail
    mailtext = str(mensagem['sujeito'])+" "+str(corpo)
    devolver o texto do correio

3. Leia o arquivo m-box de e-mail de spam

mbox = mailbox.mbox('Spam.mbox')

mlist_spam = []
#crie uma lista que contenha o texto de cada mensagem de e-mail de spam
para mensagem na mbox:
    mlist_spam.append(getmailtext(mensagem))
    #pausa
#read arquivo de e-mail mbox do ham
mbox_ham = mailbox.mbox('ham.mbox')

mlist_ham = []
contagem = 0
#create list que contém o texto do e-mail para cada mensagem de e-mail amador
para mensagem em mbox_ham:
    
    mlist_ham.append(getmailtext(mensagem))
    se contar>601:
        pausa
    contagem + = 1

4. Crie dois conjuntos de dados de e-mails de spam / ham que contém informações como o texto do e-mail, a etiqueta de envio e o comprimento do envio.

#Criar 2 dataframes para e-mails de spam que contêm as seguintes informações-
#Texto de correio, comprimento do correio, e-mail é rótulo de spam / spam
importar pandas como pd
spam_df = pd.DataFrame(mlist_spam, colunas =["mensagem"])
spam_df["rótulo"] = "Spam"

spam_df['comprimento'] = spam_df['mensagem'].mapa(texto lambda: len(texto))
imprimir(spam_df.head())

ham_df = pd.DataFrame(mlist_ham, colunas =["mensagem"])
ham_df["rótulo"] = "presunto"

ham_df['comprimento'] = ham_df['mensagem'].mapa(texto lambda: len(texto))
imprimir(ham_df.head())

51188screenshot2086-8741508

5.Função para aplicar transformações BOW e TF-IDF

def features_transform(correspondência):
    #pegue o saco de palavras para o texto do e-mail
    bow_transformer = CountVectorizer(analisador = split_into_lemmas).ajuste(mail_train)
    #imprimir(len(bow_transformer.vocabulary_))
    messages_bow = bow_transformer.transform(correspondência)
    #imprimir valor de esparsidade
    imprimir('forma de matriz esparsa:', messages_bow.shape)
    imprimir('número de não zeros:', messages_bow.nnz) 
    imprimir('sparsity: %.2f %% ' % (100.0 * messages_bow.nnz / (messages_bow.shape[0] * messages_bow.shape[1])))
    #aplique a transformação TF-IDF à saída do BOW
    tfidf_transformer = TfidfTransformer().ajuste(messages_bow)
    messages_tfidf = tfidf_transformer.transform(messages_bow)
    #imprimir(messages_tfidf.shape)
    #resultado de retorno de transformações
    retornar messages_tfidf

6. Função para imprimir as métricas de desempenho do modelo associado

#função que recebe o valor de teste y ey valor previsto e imprime as métricas de desempenho do modelo associado
def model_assessment(y_test,predicted_class):
    imprimir('matriz de confusão')
    imprimir(confusão_matriz(y_test,predicted_class))
    imprimir('precisão')
    imprimir(precisão_pontuação(y_test,predicted_class))
    imprimir('precisão')
    imprimir(precisão_score(y_test,predicted_class,pos_label ="Spam"))
    imprimir('lembrar')
    imprimir(recall_score(y_test,predicted_class,pos_label ="Spam"))
    imprimir('f-Score')
    imprimir(f1_score(y_test,predicted_class,pos_label ="Spam"))
    imprimir('AUC')
    imprimir(roc_auc_score(np.where(y_test == 'spam',1,0),np.where(predicted_class == 'spam',1,0)))
    plt.matshow(confusão_matriz(y_test, predicted_class), cmap = plt.cm.binary, interpolação = 'mais próximo')
    plt.title('matriz de confusão')
    plt.colorbar()
    plt.ylabel('rótulo esperado')
    plt.xlabel('rótulo previsto')

Vamos começar a análise comparativa de quatro modelos diferentes para obter o algoritmo de melhor desempenho.

1.Modelo Naive Bayes

Bayes ingenuo com uma abordagem de saco de palavras usando TF-IDFNaive Bayes é o algoritmo de classificação mais simples (rápido para formar, usado regularmente para detecção de spam). é um método popular (linha de base) para categorização de texto, a questão de julgar documentos como pertencentes a uma categoria ou a outra (como spam o legítimo, esportes ou política, etc.) com frequências de palavras devido às características.

Extração de recursos usando BOW:

Freqüência TF-IDFTerm: a frequência reversa do documento usa todos os tokens dentro do conjunto de dados como vocabulário. A frequência do prazo e o número de documentos durante os quais o token é produzido são responsáveis ​​por determinar a frequência reversa do documento.. O que isso garante é que, se um token ocorre frequentemente durante um documento, esse token terá um TF alto, mas se esse token ocorrer com frequência na maioria dos documentos, então reduza o IDF. Ambas as matrizes TF e IDF para um documento selecionado são multiplicadas e normalizadas para fazer o TF-IDF de um documento.

CÓDIGO

#criar e ajustar o modelo NB
modelNB = MultinomialNB()
modelNB.fit(train_features,y_train)
#transformar recursos de teste para testar o desempenho do modelo
test_features = features_transform(mail_test)
#NB predições
predicted_class_NB = modelNB.predict(test_features)
#avaliar NB
model_assessment(y_test,predicted_class_NB)

16480screenshot2087-7277460

2.Modelo de árvore de decisão

Árvores de decisão são usadas para classificação e regressão. A teoria pode ser uma medida para definir esse grau de desorganização durante um sistema chamado Entropia. O fator de entropia varia de amostra para amostra. A entropia é zero para a amostra homogênea, e para a amostra de dividendos iguais, entropia é 1. Escolha a divisão que tem uma entropia mínima em comparação com o nó principal e outras divisões. Quanto menor a entropia, maior.

CÓDIGO

#criar e ajustar o modelo de árvore
model_tree = DecisionTreeClassifier()
model_tree.fit(train_features,y_train)
#executar modelo em teste e imprimir métricas
predicted_class_tree = model_tree.predict(test_features)
model_assessment(y_test,predicted_class_tree)

83477screenshot2088-2034374

3. Máquina de vetores de suporte

Os desafios de classificação e regressão funcionam perfeitamente para este popular algoritmo de aprendizado de máquina supervisionado. (SVM). Porém, é usado principalmente em problemas de classificação. Quando trabalhamos com este algoritmo, no espaço n-dimensional, vamos representar graficamente cada item de dados até certo ponto, de modo que o valor de cada característica é o valor de uma coordenada selecionada. Máquina de vetores de suporte poderia até ser uma fronteira que melhor segregasse o 2 aulas (hiperplano / linha).

CÓDIGO

#criar e ajustar o modelo SVM
model_svm = SVC()
model_svm.ajuste(train_features,y_train)
#executar modelo em teste e imprimir métricas
predicted_class_svm=model_svm.prever(test_features)
model_assessment(y_test,predicted_class_svm)

52963screenshot2089-8103316

96288screenshot2090-3298403

4. Floresta aleatória

A floresta aleatória é como um algoritmo de bootstrap com um modelo de árvore de chamadas (CARRINHO). A previsão da última palavra pode ser uma função de cada previsão. Esta previsão final pode ser simplesmente a média de todas as previsões. A floresta aleatória fornece previsões significativamente mais precisas quando colocadas ao lado de modelos CART simples / CHAID ou regressão em muitos cenários. Esses casos geralmente têm um grande número de variáveis ​​preditoras e um grande tamanho de amostra.. Isso geralmente ocorre porque ele captura a variância de várias variáveis ​​de entrada em um tempo uniforme e permite que um grande número de observações participe da previsão..

CÓDIGO

a partir de sklearn.set importar RandomForestClassifier
#criar e ajustar o modelo
model_rf=RandomForestClassifier(n_estimators= 20,critério='entropia')
model_rf.ajuste(train_features,y_train)
#executar modelo em teste e imprimir métricas
predicted_class_rf=model_rf.prever(test_features)
model_assessment(y_test,predicted_class_rf)

44820screenshot2091-6419508

COMPARAÇÃO:-

Vendo a saída do 4 Modelos, você pode facilmente comparar e encontrar sua precisão. De acordo com a explicação acima, ordem decrescente de precisão é representada como:

PRECISÃO DO MODELO

FLORESTA ALEATÓRIA 0.77846

NAIVE BAYS 0,75076

ÁRVORE DE DECISÃO DE MODELO 0.65538

MÁQUINA DE VETOR DE SUPORTE 0.62153

RESULTADOS

Os resultados são muito claros: Random Forest é o método mais preciso para detectar e-mails de spam.. A razão para o mesmo é sua ampla capacidade de desvio para encontrar a melhor característica usando sua aleatoriedade. O modelo que não pode ser usado para tal detecção de spam é o SVM. O motivo do mesmo é sua pequena expansão. O SVM pode não ser capaz de lidar com grandes quantidades de dados.

CONCLUSÃO

Este artigo irá ajudá-lo a implementar um projeto de detecção de spam com a ajuda do aprendizado profundo. Isso é amplamente baseado em uma análise comparativa de quatro modelos diferentes. Fique ligado no Analytics Vidya para os próximos artigos. Você pode usar isso como uma referência. Sinta-se à vontade para colocar suas contribuições na caixa de bate-papo abaixo. Você também pode me enviar um ping no LinkedIn em https://www.linkedin.com/in/shivani-sharma-aba6141b6/

A mídia mostrada neste artigo não é propriedade da DataPeaker e é usada a critério do autor.

Assine a nossa newsletter

Nós não enviaremos SPAM para você. Nós odiamos isso tanto quanto você.