Conteúdo


Desenvolvimento de soluções cognitivas de IoT para detecção de anomalias usando deep learning, Parte 2

Geração de dados para detecção de anomalias

Use o Node-RED para criar um gerador de dados de teste

Comments

Conteúdos da série:

Esse conteúdo é a parte # de 5 na série: Desenvolvimento de soluções cognitivas de IoT para detecção de anomalias usando deep learning, Parte 2

Fique ligado em conteúdos adicionais dessa série.

Esse conteúdo é parte da série:Desenvolvimento de soluções cognitivas de IoT para detecção de anomalias usando deep learning, Parte 2

Fique ligado em conteúdos adicionais dessa série.

Todo projeto de dados começa com dados. Dados é um termo muito amplo. Eles podem ser estruturados ou não estruturados, grandes ou pequenos, rápidos ou lentos e precisos ou imprecisos.

Escrevi uma série de artigos sobre deep learning e o desenvolvimento de soluções cognitivas de IoT, começando com Introdução ao deep learning e às redes de memória de curto/longo prazo. Os próximos artigos são sobre o uso do Deeplearning4j, do ApacheSystemML e do TensorFlow (TensorSpark) para a detecção de anomalias. Meu caso de uso é a detecção de anomalias em dados de séries temporais de IoT, a partir de dados do sensor de vibração (acelerômetro). Para demonstrar efetivamente o processo de criação de uma solução de deep learning nessas diferentes tecnologias, preciso de dados. Preciso de dados estruturados, rápidos e big data, que também podem ser imprecisos.

Para obter uma simples estrutura de criação de dados, gravei um simulador de dados de teste, que faz parte de um kit de ferramentas maior de séries temporais e machine learning.

Esse simulador gera dados através da amostragem de diversos modelos físicos, e é possível decidir sobre o grau de imprecisão e alternar entre diferentes estados (em funcionamento ou quebrados) do modelo físico, para tarefas de detecção e classificação de anomalias.

Por enquanto, implementei o modelo Lorenz Attractor. Esse é um modelo físico muito simples, mas ainda assim, muito interessante. O Lorenz foi um dos pioneiros da teoria do caos e foi capaz de mostrar que um modelo muito simples, que consiste em apenas três equações e quatro parâmetros de modelo, pode criar um sistema caótico altamente sensível às condições iniciais e que também oscila entre diversos estados semiestáveis, nos quais as transições de estado são muito difíceis de prever.

Estou usando o Node-RED como a plataforma de tempo de execução para o simulador, pois é uma maneira muito rápida de implementar aplicativos centrados em dados. O Node-RED é um software livre e é executado inteiramente em Node.js. Se desejar saber mais sobre o Node-RED, confira este excelente tutorial.

Como o simulador de dados é implementado completamente como um fluxo do Node-RED, é possível usar o Node-RED a partir do texto padrão do IoT Starter, na IBM Cloud. Evidentemente, o simulador de dados pode ser executado em qualquer instância do Node-RED, até mesmo em um Raspberry Pi, onde pode ser usado para simular dados do sensor na borda.

Criação do simulador de dados de teste

Embora tenha sido desafiador criar o simulador de dados de teste, é possível fazê-lo funcionar em quatro etapas principais:

  1. Implemente o texto padrão do Node-RED IoT Starter na IBM Cloud.
  2. Implemente o fluxo do simulador de dados de teste.
  3. Teste o simulador de dados de teste.
  4. Obtenha as credenciais do IBM Watson IoT Platform, para consumir os dados usando o MQTT a partir de qualquer lugar do mundo.

Antes de começar, será necessária uma conta do IBM Bluemix. (É possível solicitar uma avaliação grátis aqui, que pode ser convertida em uma conta freemium posteriormente).

  1. Crie um aplicativo IBM Cloud usando o Internet of Things Platform Starter. Se ainda não efetuou, faça o login no IBM Bluemix.
  2. Nomeie seu aplicativo com um nome exclusivo e clique em Criar.
    Observação: Eu usei o romeoiotstarter123 para meu aplicativo, para certificar-me de que ele teria um nome exclusivo. O nome do aplicativo torna-se parte da URL a partir da qual seu aplicativo será acessível. Minha URL, por exemplo, é romeoiotstarter123.mybluemix.net.
  3. No menu à esquerda, clique em Conexões.
  4. Na guia Internet of Things Platform , clique em Visualizar credenciais.
  5. Anote os valores das seguintes propriedades, pois eles serão necessários mais tarde, ao trabalhar com uma das três tecnologias (DeepLearning4j, ApacheSystemML e TensorFlow (TensorSpark)):
    • org
    • apiKey
    • apiToken
  6. Clique em Fechar.
  7. Aguarde até que seu aplicativo esteja em execução e, em seguida, clique em Visitar URL do aplicativo.

    Observação: Se obtiver um erro "404 - Nenhuma rota definida", recarregue a página dentro de alguns minutos. Esse erro é um problema conhecido no componente da plataforma de nuvem do software livre Cloud Foundry e ocorre ocasionalmente, caso a IBM tenha que lidar com uma alta carga de trabalho. O Cloud Foundry se comunica de forma assíncrona entre seus componentes e, por isso, a IU pode considerar que o aplicativo está em execução, mas o balanceador de carga ainda não foi atualizado.

  8. Antes de ser possível acessar e abrir o editor de fluxo do Node-RED, é necessário proteger seu editor do Node-RED.
    1. Clique em Avançar.
    2. Configure um nome de usuário e senha.
      Observação: Selecione a caixa de seleção para compartilhar seu aplicativo com outras pessoas. Não selecionar a caixa de seleção fará com que sua implementação continue privada.
    3. Clique em Avançar.
    4. Clique em Concluir.
  9. Clique em Go to your Node-RED flow editor.
  10. Efetue login com o nome de usuário e a senha criados recentemente.
  11. Usando o mouse, selecione todos os nós em Fluxo 1; clique na tecla Excluir para esvaziá-lo.
  12. No menu da parte superior direita, clique em Importar > Área de Transferência.
  13. Abra este arquivo simulatorflow.json em Meu repositório GitHub do developerWorks; copie o objeto JSON para a área de transferência.
  14. Na janela Importar nós, cole o objeto JSON no campo de texto e clique em Importar.

    Observação: certifique-se de colar um documento JSON de sua área de transferência e não do HTML. Em sua próxima versão, o Node-RED terá a integração GIT e, portanto, essa etapa será mais fácil.

    O fluxo a seguir é exibido na guia Fluxo 1.

  15. Clique em Implementar. Será exibida a mensagem "Implementado com sucesso".

A guia depuração do programa exibirá as mensagens geradas. Parabéns! Seu gerador de dados de teste está funcionando.

Compreendendo esse fluxo do Node-RED

Ele está funcionando, mas o que acontece nesse fluxo do Node-RED?

Observe o nó rotulado com registro de data e hora..

Esse nó é um nó de inclusão e está gerando mensagens em intervalos definidos. Isso é muito útil como um ponto de início para o nosso simulador. Em um cenário real, esse nó seria substituído por alguns nós conectados a sensores do acelerômetro. Como os valores do acelerômetro estão sendo gerados através do modelo do Lorenz Attractor, é possível ignorar a carga útil de registro de data e hora nas mensagens e somente reagir ao próprio objeto da mensagem, conforme veremos mais tarde.

Dê um clique duplo no arquivo registro de data e hora . Observe que a taxa de amostra gera 100 mensagens por segundo (ou uma taxa de amostragem de 100 Hz).

Observação: A taxa de amostragem deve ser duas vezes maior que a maior frequência de captura desejada, por causa do teorema de Nyquist. Embora 100 Hz seja realmente muito baixo, para o propósito desse tutorial, ele é suficientemente alto. Em um cenário real, é recomendado realizar a amostra para 20 ou 40 kHz (cada 0,01 segundo é igual a 100 Hz).

A seguir, observe a função . Ela é o núcleo do simulador.

Clique duas vezes nesse nó e veja o seguinte código de função:

var h = context.global.get('h')||0.008;
var a = context.global.get('a')||10;
var b = context.global.get('b')||28;
var c = context.global.get('c')||8/3;
var x = context.global.get('x')||2;
var y = context.global.get('y')||3;
var z = context.global.get('z')||4;

x+=h*a*(y-x)
y+=h*(x*(b-z)-y)
z+=h*(x*y-c*z)

context.global.set("x",x);
context.global.set("y",y);
context.global.set("z",z);
msg.payload={};
msg.payload.x=x;
msg.payload.y=y;
msg.payload.z=z;
return msg;

Observação: Os parâmetros iniciais do modelo são h, funcional remoto, b e o c. Também inicializamos x, y e z para alguns valores; as equações representam o modelo real. Elas dependem de h, funcional remoto, b, c, x, y e z. Em cada etapa de tempo (atualmente 100 por segundo), o modelo tem uma etapa avançada para o futuro, pois x, y e z são atualizados usando valores de h, funcional remoto, b e c constantes e também de valores x, y e z anteriores.

É necessário configurar um limite na saída, por dois motivos:

  • Na taxa de amostra atual (100 mensagens por segundo), os 200 MB por mês gratuitos no Watson IoT Platform serão usados dentro de algumas horas.
  • É possível que a análise de recebimento de dados não consiga lidar com essa taxa de dados.

Agora, observe o nó de função limit to max 3000 . Atualmente, o máximo é configurado para 30 segundos de dados, usando uma contagem simples.

Clique duas vezes no nó para ver o código de função:

var count = context.global.get('count') || 0;
count += 1;
context.global.set('count',count);
if (count <= 3000) {
   return msg; 
}

Agora, considere reconfiguração . O nó de função associado a esse nó está configurado para enviar os próximos 30 segundos de dados para a fila de mensagens.

Clique duas vezes no nó de função. Ele será implementado conforme o seguinte:

context.global.set('count',0);
msg.payload=context.global.get('count');
return msg;

As duas próximas etapas são para alternar esse simulador entre os estados de interrupção e em funcionamento. Para simular dados defeituosos ou quebrados, é possível clicar no nó de função associado ao nó de inserção quebrado .

A única ação desse nó é atualizar as constantes do modelo do Lorenz Attractor.

context.global.set('h',0.008);
context.global.set('a',30);
context.global.set('b',128);
context.global.set('c',28/3);

return msg;

Em seguida, observe a função para voltar a um estado em funcionamento.

context.global.set('h',0.008);
context.global.set('a',10);
context.global.set('b',28);
context.global.set('c',8/3);

return msg;

Por fim, observe como os dados são transmitidos ao message broker MQTT do IBM Watson IoT Platform.

É possível não mudar a configuração, e as credenciais serão inseridas para você com o uso do Cloud Foundry em execução no IBM Bluemix.

Conclusão

Um simulador de dados de teste foi implementado com sucesso, criando uma série temporal de eventos amostrados a partir de um modelo físico. Também é possível alternar entre dois estados (em funcionamento e quebrado), para a detecção e a classificação de anomalias.

Agora, é possível usar esses dados de teste nos outros tutoriais dessa série. Será possível desenvolver soluções cognitivas de IoT de deep learning, para detecção de anomalias com Deeplearning4j, ApacheSystemML e TensorFlow (TensorSpark).


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Internet of Things, Cognitive computing, Big data e análise de dados
ArticleID=1057951
ArticleTitle=Desenvolvimento de soluções cognitivas de IoT para detecção de anomalias usando deep learning, Parte 2: Geração de dados para detecção de anomalias
publish-date=02082018