Como extrair recursos e classificar e-mails de alerta provenientes de ferramentas de monitoramento em uma categoria adequada?

Minha empresa fornece serviços gerenciados para muitos de seus clientes. Nossos clientes geralmente usam as seguintes ferramentas de monitoramento para monitorar seus servidores / aplicativos da web:

OpsView
Nagios
Pingdom
Scripts de shell customizados

Sempre que qualquer problema é encontrado, um e-mail de alerta chega à nossa equipe de Operações para que eles ajam ao corrigir o problema.

Como gerenciamos milhares de servidores, a caixa de entrada de nossas equipes de operações é inundada com alertas por email o tempo todo. Mesmo um único problema com efeito cascata pode disparar de 20 a 30 e-mails.

Agora, o que eu quero fazer é implementar um sistema que possa extrair recursos importantes de um email de alerta - como endereço IP do servidor, tipo de problema, gravidade do problema etc. e também classificar os emails na categoria apropriada, como CPU-Load-Customer1-Server2, MySQL-Replication-Customer2-DBServer3etc. Em seguida, teremos um conjunto predefinido de etapas de depuração para cada categoria, a fim de ajudar a equipe de operações a corrigir o problema mais rapidamente. Além disso, o extrator de recursos fornecerá dados de entrada para a equipe para um problema.

Até agora, pude treinar o NaiveBayesClassifier com técnicas de aprendizado supervisionadas, ou seja, dados de treinamento rotulados (dados do cluster) e capaz de classificar novos e-mails não vistos em seu cluster / categoria adequados. Como os emails são baseados em determinados modelos, a precisão do classificador é muito alta. Mas também recebemos emails de alerta de scripts personalizados, que podem não seguir os modelos. Então, em vez de fazer um aprendizado supervisionado, quero experimentar o aprendizado não supervisionado para o mesmo. Estou olhando para o cluster do KMeans . Mas, novamente, o problema é que não saberemos o número de clusters de antemão. Então, qual algoritmo será melhor para este caso de uso? No momento, estou usando a biblioteca TextBlob do Python para classificação.

Além disso, para a extração de recursos de um email de alerta, estou procurando na biblioteca do NLTK ( http://www.nltk.org/book/ch07.html ). Eu tentei, mas parece funcionar bem em parágrafos / textos em inglês apropriados; no entanto, para emails de alerta, extraímos muitos recursos desnecessários. Já existe alguma solução para o mesmo? Caso contrário, qual será a melhor maneira de implementar o mesmo? Qual biblioteca, qual algoritmo?

PS: Eu não sou um cientista de dados.

E-mails de exemplo:

PROBLEM: CRITICAL - Customer1_PROD - Customer1_PROD_SLAVE_DB_01 -  CPU Load Avg     Service: CPU Load Avg  Host: Customer1_PROD_SLAVE_DB_01  Alias: Customer1_PROD_SLAVE_DB_01  Address: 10.10.0.100  Host Group Hierarchy: Opsview > Customer1  - BIG C > Customer1_PROD  State: CRITICAL  Date & Time: Sat Oct 4 07:02:06 UTC 2014    Additional Information:     CRITICAL - load average: 41.46, 40.69, 37.91
RECOVERY: OK - Customer1_PROD - Customer1_PROD_SLAVE_DB_01 -  CPU Load Avg     Service: CPU Load Avg  Host: Customer1_PROD_SLAVE_DB_01  Alias: Customer1_PROD_SLAVE_DB_01  Address: 10.1.1.100  Host Group Hierarchy: Opsview > Customer1  - BIG C > Customer1_PROD  State: OK  Date & Time: Sat Oct 4 07:52:05 UTC 2014    Additional Information:     OK - load average: 0.36, 0.23, 4.83
PROBLEM: CRITICAL - Customer1_PROD - Customer1_PROD_SLAVE_DB_01 -  CPU Load Avg     Service: CPU Load Avg  Host: Customer1_PROD_SLAVE_DB_01  Alias: Customer1_PROD_SLAVE_DB_01  Address: 10.100.10.10  Host Group Hierarchy: Opsview > Customer1  - BIG C > Customer1_PROD  State: CRITICAL  Date & Time: Sat Oct 4 09:29:05 UTC 2014    Additional Information:     CRITICAL - load average: 29.59, 26.50, 18.49

Código do classificador: (formato de csv - email, <disk / cpu / memory / mysql>)

from textblob import TextBlob
from textblob.classifiers import NaiveBayesClassifier
import csv
train = []
with open('cpu.txt', 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',', quotechar='"')
    for row in reader:
        tup = unicode(row[0], "ISO-8859-1"), row[1]
        train.append(tup)
// this can be done in a loop, but for the time being let it be
with open('memory.txt', 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',', quotechar='"')
    for row in reader:
        tup = unicode(row[0], "ISO-8859-1"), row[1]
        train.append(tup)

with open('disk.txt', 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',', quotechar='"')
    for row in reader:
        tup = unicode(row[0], "ISO-8859-1"), row[1]
        train.append(tup)

with open('mysql.txt', 'r') as csvfile:
    reader = csv.reader(csvfile, delimiter=',', quotechar='"')
    for row in reader:
        tup = unicode(row[0], "ISO-8859-1"), row[1]
        train.append(tup)

cl = NaiveBayesClassifier(train)
cl.classify(email)

Código extrator do recurso retirado de: https://gist.github.com/shlomibabluki/5539628

Entre em contato se precisar de mais informações aqui.

Desde já, obrigado.

— Kartikeya Sinha
fonte

Você pode começar a converter cada email no vetor tf-idf scikit-learn.org/stable/modules/feature_extraction.html . Encontrar o número certo de K é um problema complicado, isso pode ajudar stackoverflow.com/questions/1793532/…

— Saurabh Saxena

Muito bom caso de uso. Mas acho que você está misturando "extração de recursos", "precisão de classificação" e "aprendizado supervisionado". Quero dizer, não poder analisar um e-mail facilmente não implica que você não possa fazer um aprendizado supervisionado. É tudo sobre conhecer as aulas com antecedência e ter dados de trem classificados, e ambos podem ser reunidos no seu caso.

— Amir Ali Akbari

@SaurabhSaxena A execução do TF-IDF em tempo real, como e quando recebemos um novo email de alerta, é impossível, pois o TF-IDF precisa ser executado em todo o corpus do documento e não apenas no novo email. Obrigado pelos links e informações.

— Kartikeya Sinha

@AmirAliAkbari Eu não entendo. O caso de uso que tenho, deve ter a combinação de "extração de recursos" de informações importantes do e-mail, "agrupamento supervisionado" de e-mails em grupos para roteamento de e-mail e "classificação" de novos e-mails em um cluster adequado com precisão. A precisão é importante aqui, porque um carregamento de CPU no email de alerta do servidor de aplicativos deve ser classificado como email de alerta de espaço em disco do servidor MySQL DB. :)

— Kartikeya Sinha

Quero experimentar o aprendizado não supervisionado para o mesmo. Eu estou olhando para o cluster do KMeans. Mas, novamente, o problema é que não saberemos o número de clusters de antemão. Então, qual algoritmo será melhor para este caso de uso?

Quando você não conhece o número de clusters antecipadamente, ainda é possível fazer um aprendizado não supervisionado usando um processo Dirichlet para amostrar parâmetros associados a clusters / grupos e, em seguida, agrupar seus tokens de acordo com esses parâmetros. A idéia geral é usar uma distribuição Dirichlet para gerar probabilidades sobre palavras para cada cluster e um processo Dirichlet usa essas probabilidades para atribuir um cluster a cada palavra em seu vocabulário. Se você deseja compartilhar clusters entre emails, use Processos Hierárquicos de Dirichlet. Aqui você pode encontrar um bom post sobre como isso funciona.

A biblioteca mais popular para armazenamento em cluster é o gensim , mas observe o aviso sobre a implementação do Processo de Dirichlet Hierárquico:

O gensim usa uma implementação rápida e online baseada em [3]. O modelo HDP é uma nova adição ao gensim, e ainda é difícil em relação às suas margens acadêmicas - use com cuidado.

Quanto à extração de recursos, sua pergunta não diz exatamente que tipo de recursos desnecessários você está recebendo, mas se for esse o caso, você precisa filtrar seus tokens antes ou depois de processá-los com o NLTK. Em geral, você não pode esperar excelentes resultados para aplicações muito específicas.

— Robert Smith
fonte