Usando Deeplearning4j para detecção de anomalias e para criar rede neural – Blue</>Dev
Usando Deeplearning4j para detecção de anomalias e para criar rede neural
Romeo Kienzler Posted On 7 de maio de 2019
Crie uma rede neural de deep learning no Apache Spark com o Deeplearning4j
No primeiro artigo desta série, Introduzindo deep learning e redes de memória de longo prazo, passei algum tempo introduzindo conceitos sobre aprendizagem profunda e redes neurais. Também descrevi um caso de uso de demonstração na detecção de anomalias para dados de séries temporais de IoT. Nossa tarefa é detectar anomalias nos dados do sensor de vibração (acelerômetro) em um rolamento.
Figura 1. O sensor acelerômetro em um rolamento registra vibrações em cada um dos três eixos geométricos x, y e z
Como é difícil levar um sistema desse tipo com você, eu gerava dados de teste usando um modelo físico do Atrator Lorenz porque ele é capaz de gerar um fluxo de dados tridimensional. Eu usei os dados gerados nesta demonstração para detectar anomalias, prevendo quando um rolamento está prestes a quebrar.
Precisamos fazer alguma configuração do ambiente de desenvolvimento, mas uma visão geral do processo é a seguinte:
Os dados de teste são gerados no Node-RED e executados no IBM Cloud (ou, alternativamente, em um IoT Gateway como um Raspberry Pi para simular um cenário ainda mais realista).
O Watson IoT Platform Service é usado como o intermediário de mensagens MQTT (também em execução na nuvem).
O Eclipse, instalado em sua área de trabalho e executando um sistema de deep learning, assina os dados no intermediário de mensagens MQTT.
Como vamos implantar os dados de teste do Node-RED na plataforma IBM Cloud? Qual sistema de deep learning vamos usar? Várias tecnologias diferentes existem para implementar um sistema de deep learning. Como mencionado, essas soluções de padrão aberto e de código aberto podem ser executadas no IBM Cloud: Deeplearning4j, ApacheSystemML e TensorFlow (TensorSpark). Este artigo apresentará a solução Deeplearning4j.
Uma conta do IBM Cloud. (Inscreva-se para uma Conta IBM Cloud Lite, uma conta gratuita que nunca expira.
Eclipse (um ambiente de desenvolvimento integrado (IDE) para idiomas baseados em JVM).
Eclipse Maven Plugin (gerenciamento de dependências e ferramenta de compilação automatizada).
Plugin Eclipse Scala (linguagem de programação).
Plugin Eclipse GIT (sistema de controle de versão).
Antes de falarmos sobre o caso de uso de deep learning, gaste algum tempo configurando seu ambiente de desenvolvimento.
Instale o Plug-in do Eclipse Maven.
Instale o Plug-in Eclipse Scala conforme descrito para Scala 2.10.
Instale o Plugin do Eclipse GIT.
Siga as instruções nos documentos de introdução do meu repositório no GitHub deeplearning4j para importar o código-fonte para este tutorial.
Finalize a configuração.
a. Mude para a perspectiva do Scala. Clique com o botão direito do mouse no projeto dl4j-examples-spark e, em seguida, clique em Configure > Add Scala Nature.
b. Clique com o botão direito do mouse no projeto dl4j-examples-spark novamente e clique em Maven > Update Project.
Nota: Ignore os erros do Maven. Enquanto Run.scala compilar sem erro você está bem!
c. Atualize src/resources/ibm_watson_iot_mqtt.properties com as credenciais do IBM Watson IoT Platform. Especifique o Organization-ID, o Authentication-Method (apikey), a API-Key e o Authentication-Token. Você anotou essas credenciais no meu artigo "Generating data for anomaly detection.
a. Abra o explorador de pacotes do Eclipse.
b. No projeto dl4j-examples-scala, expanda a pasta src/main/scala.
c. Localize o arquivo Run.scala, clique com o botão direito do mouse no arquivo e selecione Run As > Scala Application. Você deve ver a seguinte saída.
imagem | Saída da aplicação Scala
Nota: Ignore avisos que o Vfs.Dir não foi encontrado. Esses são apenas avisos e não afetam o comportamento do aplicativo.
Parabéns, a parte mais importante é funcionar. Pare o aplicativo clicando no botão vermelho Stop no canto superior direito da janela. Vamos executar este aplicativo novamente durante um estágio posterior no artigo.
Deeplearning4j é um kit de ferramentas baseado em Java. É um deep learning distribuído de código aberto e executado em muitos ambientes diferentes, incluindo o Apache Spark. O Deeplearning4j não precisa de nenhum componente adicional para ser instalado porque é um aplicativo Apache Spark nativo que usa as interfaces que o Apache Spark fornece.
Os componentes mais importantes do framework para este artigo são:
O tempo de execução do Deeplearning4j é o módulo principal. Com este módulo de tempo de execução, você pode definir e executar todos os tipos de redes neurais no topo (mas não diretamente no) Apache Spark usando uma biblioteca de tensor.
ND4J é uma biblioteca de computação científica para a JVM. Esta biblioteca de tensores é realmente o coração do Deeplearning4j. Ele pode ser usado de forma independente e fornecer álgebra linear acelerada sobre CPUs e GPUs. Para portar código para uma GPU, nenhuma alteração de código é necessária porque uma propriedade da JVM configura o mecanismo de execução subjacente, que também pode ser um backend CUDA para placas de GPU da nVidia.
ND4J é uma biblioteca de álgebra tensorial e linear. Isso significa que arrays multidimensionais (também chamados de tensores) e operações neles são o objetivo principal. As operações são simples, mas rápidas. As vantagens de usar o ND4J são:
Ao usar o Apache Spark, você permanece no mesmo processo da JVM e não precisa pagar a sobrecarga da comunicação entre processos (IPC).
O ND4J é capaz de usar conjuntos de instruções SIMD em CPUs modernas, o que dobra o desempenho do ND4J em relação a outra biblioteca de tensores como o NumPy. Isso é conseguido usando o OpenBLAS, uma implementação de código aberto da API de Subprogramas de Álgebra Linear Básica (BLAS).
O ND4J pode aproveitar as GPUs presentes em sua máquina simplesmente definindo uma propriedade do sistema na JVM (desde que uma versão recente dos drivers e da estrutura do CUDA esteja instalada em seu sistema).
Como o ND4J pode aproveitar as GPUs? Veja esta sintaxe do Scala para entender como funciona:
Como você pode ver, criei duas matrizes v e w do tipo INDArray usando o método Nd4j.create. Eu forneci uma matriz Scala aninhada do tipo double, que eu posso criar inline assim:
O código v.mul(w) dispara a multiplicação da matriz. Mais uma vez, em uma CPU ou GPU. Mas isso é totalmente transparente para nós.
Pratique o treinamento de uma rede neural usando a operação XOR
Agora que você pode ver o que o ND4J pode fazer, quero mostrar como criar uma rede neural. Antes de começarmos com os dados da série temporal da IoT, comece com um exemplo XOR. Primeiro, usando o Scala, gere alguns dados de treinamento em linha:
Lista de valores de entrada: 4 amostras de treinamento com dados para 2 neurônios de entrada cada.
Lista correspondente com valores de saída esperados, 4 amostras de treinamento com
dados para 2 neurônios de saída cada.
Crie o primeiro conjunto de dados quando a primeira entrada input=0 e a segunda entrada input=0.
Então a primeira saída é acionada para false e a segunda é 0 (veja o comentário da classe).
Quando o primeiro input=1 e o segundo input=0.
Então XOR é verdadeiro, portanto o segundo neurônio de saída dispara.
Quando ambas as entradas são acionadas, o XOR é falso novamente. A primeira saída deve disparar.
Agora que criamos dois arrays ND4J, um chamado input contendo os recursos e um chamado labels contendo o resultado esperado. Apenas como um lembrete, veja as entradas e saídas em.
Tabela 1. Entradas e saídas da tabela de funções XOR
Nota: A saída é apenas 1 se apenas uma entrada for 1.
Agora, vamos usar os dados que criamos acima para treinamento em redes neurais.
A matriz DataSet, que não deve ser confundida com a do Apache Spark SQL, é uma estrutura de dados Deeplearning4j contendo matrizes ND4J para treinamento. Aqui está o como a representação matemática interna deste array ND4J se parece:
Essa matriz reflete a estrutura da tabela de função XOR com duas diferenças:
ND4J usa float como representação de tipo de dados interno.
A saída está em forma binária, isto é, uma matriz bidimensional. Arrays bidimensionais são muito úteis para treinar classificadores binários com redes neurais, onde temos dois neurônios de saída, porque a classificação binária é feita usando dois neurônios de saída em vez de um. Após o treinamento, cada neurônio de saída gera uma probabilidade de ser uma ou outra classe.
1 – Crie uma rede neural Deeplearning4j para XOR
Ainda usando nossas entradas e saídas XOR, vamos definir e criar redes neurais em Deeplearning4j com o NeuralNetConfiguration.Builder class.
Você pode encontrar todo o código que discutirei nas seções a seguir no XOrExampleScala.
1a – Defina os parâmetros globais
Este código basicamente define parâmetros globais para a rede neural. Explorar cada um desses parâmetros está além do escopo deste artigo.
Com que frequência o conjunto de treinamento deve ser executado? Precisamos de algo acima de
1000, ou uma taxa de aprendizagem mais alta; Encontrei este valor apenas por tentativa e erro.
Semente fixa para o gerador aleatório. Qualquer execução deste programa
traz os mesmos resultados. Pode não funcionar se você fizer algo como ds.shuffle()
Não aplicável, pois esta rede é muito pequena, mas para redes maiores
pode ajudar que a rede é menos propensa a overfitting para os dados de treinamento.
Um algoritmo padrão para se mover no plano de erro. Este aqui funciona
melhor para mim. LINE_GRADIENT_DESCENT ou CONJUGATE_GRADIENT podem fazer o
trabalho também. É um valor empírico que combina melhor para
Inicialize o viés com 0; valor empírico também.
De "http://deeplearning4j.org/architecture": As redes podem
processar a entrada com mais rapidez e precisão, ingerindo
minibatches de 5 a 10 elementos de uma vez em paralelo.
Este exemplo funciona melhor sem, porque o conjunto de dados é menor que
o tamanho do minibatch.
Crie uma rede multicamada com duas camadas (incluindo a camada de saída, excluindo a camada de entrada)
Duas conexões de entrada definem simultaneamente o número de entrada
de neurônios, porque é a primeira camada sem entrada.
Número de conexões de saída, nOut define simultaneamente o
Coloque a saída através da função sigmóide, para limitar a saída do
valor entre 0 e 1.
Aleatório, inicializar pesos com valores entre 0 e 1.
1b – Configure as camadas da rede neural
Depois de definir os parâmetros globais, precisamos adicionar camadas de redes neurais individuais para formar uma rede neural profunda. Este código adiciona duas camadas à rede neural, uma camada de entrada com dois neurônios (cada um para uma coluna da tabela de funções XOR mostrada) e uma camada de saída com dois neurônios, um para cada classe (como resultado zero e um na tabela de funções XOR).
Nota: Podemos especificar uma abundância de parâmetros específicos da camada, mas isso está além do escopo deste artigo.
Construa e defina como camada 0.
MCXENT ou NEGATIVELOGLIKELIHOOD (ambos são matematicamente equivalentes) funcionam para este exemplo. Esta função
calcula o valor do erro ( ou 'custo' ou 'valor de perca da função' e quantifica
ou ruim de uma previsão, de maneira diferenciável.
Para classificação (com classes mutuamente exclusivas, como aqui), use entropia cruzada multiclasse, em conjunto
com função de ativação softmax.
Deve ser a mesma quantidade de neurônios na camada anterior.
Dois neurônios nessa camada.
1c – Crie a rede neural
Você tem os parâmetros globais e as camadas da rede neural, agora crie a rede neural.
Nenhuma fase de pré-treino para esta rede.
Parece ser obrigatório
de acordo com agibsonccc: Você normalmente só usa isso com
pretrain(true) quando você quer fazer o pretrain/finetune sem mudar
as camadas anteriores que têm pesos com ajustes finos que são para autoencodificadores e máquinas restritas de Boltzmann (RBMs).
Construa e inicialize a rede e verifique se tudo está configurado corretamente.
1d – Treine a rede neural com dados XOR
Agora a variável net contém nossa rede neural pronta e a única coisa que temos que fazer para treiná-la com nossa tabela de função XOR é o seguinte código.
Se olharmos agora para a saída (sysout), veremos a mensagem de depuração sobre como o aprendizado progride.
08:52:56.714 [main] INFO o.d.o.l.ScoreIterationListener ‑ Score at iteration 400 is 0.6919901371002197
08:52:56.905 [main] INFO o.d.o.l.ScoreIterationListener ‑ Score at iteration 500 is 0.6902942657470703
08:52:57.085 [main] INFO o.d.o.l.ScoreIterationListener ‑ Score at iteration 600 is 0.6845208406448364
08:53:11.720 [main] INFO o.d.o.l.ScoreIterationListener ‑ Score at iteration 9700 is 0.0012604787480086088
08:53:11.847 [main] INFO o.d.o.l.ScoreIterationListener ‑ Score at iteration 9800 is 0.0012446331093087792
08:53:11.994 [main] INFO o.d.o.l.ScoreIterationListener ‑ Score at iteration 9900 is 0.001229131012223661
Como você pode ver, existem 9900 iterações nas quais a rede neural é treinada (basicamente o mesmo conjunto de dados é mostrado para a rede neural várias vezes) e a cada 100 iterações uma medida chamada pontuação é impressa. Este é o chamado RMSE (root-mean-square error), uma medida de quão bem a rede neural se ajusta aos dados; quanto menor, melhor. Como você pode observar após 10000 iterações, o RMSE desceu para 0.001229131012223661, o que é um valor muito bom neste caso.
1e – Avalie o quão bem o treinamento se saiu
Podemos verificar o quão bem estamos realmente indo, porque o Deeplearning4j possui um componente interno para a avaliação.
Deixe a avaliação imprimir estatísticas sobre a frequência com que a saída certa tinha a etiqueta correta.
O código gera as seguintes medidas no desempenho de previsão (classificação):
Conseguir um para todas as medidas significa que conseguimos 100% e construímos um classificador perfeito para computar o XOR.
2 – Crie uma rede neural Deeplearning4j para detecção de anomalias
Aprender a treinar uma rede neural usando o XOR como exemplo foi educacional, mas agora precisamos construir algo útil no Apache Spark com o Deeplearning4j usando um conjunto de dados gerado. Lembre-se de que usamos um modelo do Atrator Lorenz para obter dados simulados do sensor de vibração em tempo real. E precisamos obter esses dados para a plataforma IBM Cloud; veja meu artigo "Gerando dados para detecção de anomalias" para as etapas.
Estou usando o Scala porque ele não é apenas semelhante ao Java, ele também é considerado uma linguagem de ciência de dados. Este exemplo consiste em três classes Scala.
O WatsonIoTConnector é responsável por assinar dados em tempo real do intermediário de mensagens MQTT.
A execução contém alguma cola entre o WatsonIoTConnector e o IoTAnomalyExampleLSTMFFTWatsonIoT.
2a – Assine o IBM Watson IoT Platform com MQTT para ingerir o fluxo de dados do sensor de IoT em tempo real
Comece com o WatsonIoTConnector primeiro. Eu só estou mostrando código relevante aqui, mas você pode baixar o código completo do meu repositório GitHub, dl4j-examples.
Primeiro, crie um cliente de aplicativo MQTT para assinar um fluxo de dados do sensor MQTT.
props.load(getClass.getResourceAsStream("/ibm_watson_iot_mqtt.properties"))
Agora você pode se inscrever nos chamados eventos de dispositivo. Como provavelmente não queremos receber todo o tráfego que está acontecendo no barramento de mensagens, ficamos felizes em filtrá-lo. Essa é uma maneira muito inteligente de desvincular os sensores conectados aos dispositivos e gateways de IoT dos aplicativos analíticos reais, porque eles não precisam mais saber nada um do outro. Então, como reagimos aos dados recebidos? Por um manipulador de retorno de chamada que é definido na instância myClient do ApplicationClient.
Veja este manipulador de eventos definido na classe Run.
A primeira coisa que fazemos é criar uma variável fifo para armazenar uma janela de contagem de eventos.
var fifo: Queue[Array[Double]] = new CircularFifoQueueArray[Double]
Em seguida, implementamos o método processEvent, que está sendo chamado sempre que uma mensagem chega da fila do MQTT.
Agora converta o evento em uma matriz do tipo double e adicione-o ao objeto fifo.
val json = arg0.getData().asInstanceOfJsonObjectdef conv = { v: Object => v.toString.toDouble }
val event: Array[Double] = Array(conv(json.get("x")), conv(json.get("y")), conv(json.get("z")))
Depois que nossa janela de contagem decrescente é preenchida, aplicamos a transformação rápida de Fourier (FFT) para obter o espectro de freqüência dos sinais e, finalmente, transformá-la em um NDArray, um tipo de dados interno Deeplearning4j.
val ixNd = Nd4j.create(fifo.toArray(Array.ofDimDouble));
Agora é hora de instanciar a rede neural.
Depois disso, podemos enviar nossa janela de contagem decrescente para a rede neural para detectar anomalias.
Nota: A detecção de treinamento e anomalia está ocorrendo ao mesmo tempo, porque a rede neural aprende continuamente como são os dados normais e, depois de ver anomalias, irá gerar um erro.
2b – Cria o codificador automático LSTM da rede neural profunda para detecção de anomalias
Mas como essa mágica acontece? Vamos dar uma olhada em nossa implementação de rede neural em IoTAnomalyExampleLSTMFFTWatsonIoT:
Primeiro, definimos os parâmetros globais para a rede neural, como a taxa de aprendizado, por exemplo. E então é hora de adicionar as camadas reais. Começaremos com uma camada LSTM (Long-Short Term Memory) – a camada responsável por reconhecer padrões temporais em nosso fluxo de dados do sensor de série temporal IoT.
Para detectar anomalias, é crucial usar um autoencoder, que será adicionado como segunda camada.
// 2 camadas de codificador, cada uma com tamanho 256
.decoderLayerSizes(256, 256)
// 2 camadas decodificadoras, cada uma com tamanho 256
// Distribuição de reconstrução de Bernoulli + ativação sigmóide – para modelagem de dados binários (ou dados no intervalo de 0 a 1)
.nIn(10) //Input size: 28×28
.nOut(10) //Size of the latent variable space: p(z|x) ‑ 32 values
Finalmente, concluímos com uma camada de saída e terminamos.
2c – Executa a rede neural em uma única máquina local
Agora vamos, primeiro, ver como seria uma configuração de nó único.
Isso é tudo! Nós apenas usamos a configuração e obtemos um objeto de rede neural no qual podemos treinar. Ir de um único node para o Apache Spark é realmente muito fácil em Deeplearning4j.
2d – Paralelize esta rede neural usando o Apache Spark
Vamos pular o TrainingMaster, por enquanto, e dar uma olhada na assinatura do construtor do SparkDl4jMultiLayer. O parâmetro conf já sabemos; esta é a configuração da rede neural. Então, sc significa SparkContext, que temos disponível quando estamos usando o Apache Spark. Finalmente, vamos verificar o TrainingMaster. O treinamento paralelo de redes neurais ocorre usando a média dos parâmetros. Durante o treinamento, os parâmetros ou pesos da rede neural são atualizados em cada iteração de treinamento. Como várias redes neurais são treinadas em paralelo em diferentes partições de dados, os parâmetros aprendidos de cada rede neural individual são enviados para o servidor de parâmetros aqui e, em seguida, para onde estão sendo calculados e enviados de volta.
Vamos revisar o código-fonte a seguir para ver as diferenças mínimas no código-fonte para alternar da execução local para a paralela no topo do Apache Spark.
Para saber mais sobre o treinamento da rede neural no DL4J e no Apache Spark, leia este artigo no site deeplearning4j.org.
sparkConf.setAppName("DL4J Spark Example");
Se runLocal for false, um ParameterAveragingTrainingMaster será instanciado; em execução no Apache Spark master, ele é responsável pelo treinamento da rede neural paralela. Em seguida, o sparkNet é criado usando o SparkContext, a configuração real da rede neural conf e a instância do Master de Treinamento que acabamos de criar, todos usando o construtor do SparkDl4jMultiLayer. Se você quiser saber mais sobre como o Parameter Averaging trabalha em detalhes, por favor veja a explicação do paralelismo de dados em meu vídeo, "Parallelization Strategies of DeepLearning Neural Networks" (que está no ponto de 8:19 neste vídeo de 32:11 min).
2e – Fecha o loop
Então, vamos finalmente fechar o loop, mostrando a implementação do método detect, que é chamado diretamente do manipulador de retorno de chamada do MQTT após a janela de contagem decrescente estar cheia.
for (a <‑ 1 to 1000) {
Isso não faz mais nada além de mostrar os mesmos dados várias vezes para a rede neural. Na verdade, funciona melhor ter uma taxa de aprendizado menor e treinar repetidamente uma rede neural com o mesmo conjunto de dados. Aqui estamos mostrando a rede neural, o mesmo conjunto de dados, 1000 vezes.
3 – Inicie a rede neural local e veja como ela reage aos dados recebidos
Vamos começar o processo e ver o que acontece. Nós faremos duas rodadas de treinamento com dados saudáveis e, finalmente, mudaremos o gerador de dados de teste para um estado quebrado. Veremos uma diferença significativa no chamado erro de reconstrução que a rede neural experimenta quando, de repente, vê dados desconhecidos após algum tempo de treinamento com dados normais.
Primeiro, execute a classe Run.scala novamente, conforme descrito na seção "Configurando seu ambiente de desenvolvimento". Você deverá ver uma saída semelhante à figura a seguir.
Essa saída significa que a rede neural foi instanciada localmente e estamos aguardando que os dados cheguem em tempo real a partir do intermediário de mensagens do IBM Watson IoT Platform MQTT.
Em seguida, volte para a janela do navegador da sua instância do Node-RED na qual o gerador de dados de teste está sendo executado. Inicie o gerador de dados de teste clicando no botão Redefinir para produzir alguns dados.
Nota: Embora o modelo de Atração de Lorenz gere dados continuamente (como um sensor de acelerômetro real anexado a um rolamento), somente quando pressionarmos o botão Redefinir, ele publicará outros 30 segundos de dados no corretor de mensagens do IBM Watson IoT Platform MQTT; isso impede que a nossa rede neural em execução local seja descartada.
Você pode observar na área de janela de depuração Node-RED como os dados são transmitidos para o intermediário de mensagens porque o fluxo contém nodes que estão assinando e depurando o mesmo fluxo de dados.
Figura 4. Fluxo Node-RED que mostra os nodes para assinar o fluxo de dados
Por último, volte para o Eclipse, onde a nossa rede neural está em execução. Você vê no console em algumas mensagens de depuração que os dados estão chegando. Estamos aguardando o preenchimento de uma janela com base em contagem para que ela contenha 30 segundos de dados. Vamos enviar cada janela de queda para a rede neural.
Figura 5. Guia de depuração de fluxo Node-RED que mostra os dados que estão chegando
Mostra a saída da rede neural durante o treinamento após ter recebido a primeira janela rolante para processamento. Ele imprime a iteração de treinamento real e o erro de reconstrução atual. É importante que o número converta para um mínimo local após algum tempo e também que haja uma queda significativa do erro de reconstrução após algum tempo.
Em que começamos na iteração 0 com um erro de reconstrução inicial de 392314.67211754626. Isso se deve à inicialização aleatória dos parâmetros de peso da rede neural.
Figura 7. Saída de treinamento de rede neural com iterações de dados saudáveis de 0 a 30
Nota: Toda vez que executarmos este exemplo, obteremos números ligeiramente diferentes.
Na figura a seguir, acabamos com um erro de reconstrução de 372.6741075529085 na iteração 999, que é significativamente menor que a iteração 0 em 392314.67211754626.
Figura 8. Saída de treinamento de rede neural com iterações de dados saudáveis de 969 a 999
Na figura, depois de uma segunda rodada de treinamento – e após o processamento da segunda janela de contagem decrescente – acabamos com um erro de reconstrução de 77.8737141122287 na iteração de 1999.
Nota: Você pode ver que a pontuação na iteração de 1999 é maior que na iteração de 1969. Isso ocorre devido a oscilações, mas não significa que haja um problema, a menos que você esteja convergindo para algum valor baixo.
Figura 9. Saída de treinamento da rede neural com iterações de dados saudáveis de 1969 a 1999
Como você pode ver na figura, agora nós alimentamos dados anormais na rede neural e podemos ver claramente que o erro de reconstrução de 11091.125671441947 na iteração 2999 é significativamente maior.
Figura 10. Saída de treinamento de rede neural com iterações de dados saudáveis de 969 a 999
Nota: Eu demonstrei este cenário de ponta a ponta na conferência do HadoopSummit 17, que você pode assistir neste video (Eu começo a demonstração no ponto 25:06 neste vídeo de 34:47 min).
Isso conclui nosso primeiro tutorial de deep learning para dados de séries temporais de IoT. Como você viu, definir e executar uma rede neural profunda é simples no DeepLearning4J. O framework DeepLearning4j cuida de toda a matemática complexa envolvida no treinamento de redes neurais paralelas. Executá-lo no Apache Spark o torna um candidato ideal para a criação de soluções de IoT cognitivas altamente escaláveis em ambientes elásticos de nuvem Apache Spark, como o IBM Watson Studio, que tem sua oferta Apache Spark "as a Service" elasticamente escalável. Além disso, você não se prende a um provedor de nuvem específico e pode até mesmo executar esse sistema em sua própria nuvem privada ou em um data center tradicional.
Nos próximos dois artigos, trabalharemos com os mesmos dados de teste gerados, mas com dois frameworks de deep learning diferentes: ApacheSystemML e TensorFlow (TensorSpark).