Classificar dados treinando sua própria rede neural

Nota

Eu escrevi o artigo original em espanhol. Portanto, algumas referências a recursos e código estão em espanhol.

Introdução

Uma rede neural pode ser alimentada com grandes quantidades de dados. Ao processar esses dados, a rede nos permite realizar classificação e regressão nas informações. Neste artigo, alimentaremos uma rede neural com informações que usaremos posteriormente para fazer estimativas com base nos dados utilizados.

Como exemplo, usaremos um quadrado. Suponha que temos um quadrado com dimensões 1000 x 1000 onde 0,0 é o canto superior esquerdo e 1000,1000 é o canto inferior direito. Usaremos este arquivo .json chamado coordenadas.json que contém 41 blocos de coordenadas que definem um ponto no quadrado e uma descrição deles. Nosso objetivo é alimentar essas informações para a rede neural para que possamos passar outros valores que não estão no .json e fazer com que ela classifique se a coordenada corresponde à esquerda superior, esquerda inferior, direita superior ou direita inferior do quadrado.

Requisitos

Para realizar este tutorial precisamos:

Um editor de texto. (É recomendado usar vscode).
Ter o NodeJs instalado com o NPM.
Um navegador web como Firefox, Chrome ou Edge Chromium.

Criação de Arquivos

Criamos uma pasta e colocamos os seguintes arquivos:

recursos/

index.html

index.js

Dentro da pasta recursos/ colocaremos o arquivo coordenadas.json.

No arquivo index.html colocamos o seguinte código, que basicamente traz a biblioteca ml5.js no head.

html

<html>
  <head>
    <meta charset="UTF-8" />
    <title>Classificar dados treinando sua própria rede neural</title>
    <script src="https://unpkg.com/ml5@0.4.3/dist/ml5.min.js"></script>
  </head>

  <body>
    <script src="index.js"></script>
  </body>
</html>

No arquivo index.js colocamos o seguinte (código explicado nos comentários):

window.onload = () => {
  /**
   * Opções da rede neural
   * dataUrl: url do arquivo .json onde estão localizados nossos dados.  
   * task: Tipo de tarefa a ser executada na rede, para este exemplo usaremos 'classification'
   * inputs: Dados de entrada, ou seja, a fonte de dados usada para alimentar a rede.
   * outputs: Dados de saída, ou seja, a descrição dos dados de entrada.
   * debug: Define se deve ou não mostrar a visualização do treinamento da rede neural no html.
   */
  const options = {
    dataUrl: 'recursos/coordenadas.json',
    task: 'classification',
    inputs: ['x', 'y'],
    outputs: ['label'],
    debug: true,
  };

  // inicializa a rede neural
  const nn = ml5.neuralNetwork(options, normalize);

  // normaliza os dados
  function normalize() {
    nn.normalizeData();
    train();
  }

  // treina o modelo de dados  
  function train() {
    /**
     * epochs: Em termos de redes neurais, uma 'epoch' se refere a um ciclo completo sobre os dados de treinamento.
     * batchSize: Blocos de dados nos quais as informações serão processadas.
     *
     * Não há um número específico de epochs necessárias, mas testes podem ser feitos para encontrar o número ideal de acordo com os resultados.
     */
    const trainigOptions = {
      epochs: 250,
      batchSize: 12,
    };
    nn.train(trainigOptions, classify);
  }

  // uma vez que nossa rede neural esteja treinada, procedemos para testar como ela se comporta com dados desconhecidos.
  function classify() {
    // neste exemplo estamos passando as coordenadas 300,350 que correspondem ao lado inferior esquerdo.
    const input = {
      x: 300,
      y: 350,
    };
    nn.classify(input, handleResults);
  }

  function handleResults(error, results) {
    // em caso de erro, o colocamos no console
    if (error) {
      console.log(error);
      return;
      // se tudo der certo, podemos ver no console do navegador os resultados da classificação realizada.  
    } else {
      console.log(results);
    }
  }
};

Execução do Código

Instalamos um servidor leve chamado serve. Abra o console de comando e digite:

shell

npm install -g serve

Em seguida, uma vez que o serve esteja instalado, na pasta do projeto, abra o console e digite:

shell

serve

Por padrão, isso cria um servidor simples executando em http://localhost:5000. Ao navegar para este url, podemos abrir as ferramentas de desenvolvedor do navegador e observar enquanto os dados são processados em nossa rede neural. Ao executar este exercício, podemos visualizar um gráfico semelhante a este:

Desempenho do Treinamento da RN

E no console obter resultados aproximados a estes:

[
  { label: 'izquierda-superior', confidence: 0.8469865322113037 },
  { label: 'izquierda-inferior', confidence: 0.09941432625055313 },
  { label: 'derecha-superior', confidence: 0.0454748310148716 },
  { label: 'derecha-inferior', confidence: 0.008124231360852718 },
];

Podemos ver que a rede neural classificou com sucesso que as coordenadas correspondem ao lado superior esquerdo com uma confiança de 0,847 ou 84,7%. Podemos testar com coordenadas diferentes e ver se a estimativa da rede neural, com base nos dados com os quais foi alimentada, ainda está correta.

Testando para { x: 800, y: 150 }:

[
  { label: 'derecha-superior', confidence: 0.9378078579902649 },
  { label: 'izquierda-superior', confidence: 0.05480305105447769 },
  { label: 'derecha-inferior', confidence: 0.007157310843467712 },
  { label: 'izquierda-inferior', confidence: 0.0002319106279173866 },
];

De acordo com os resultados, podemos observar que a classificação novamente foi bem-sucedida com 93% de confiança para o lado superior direito.

Com esses exemplos, podemos ter uma ideia do potencial das redes neurais na classificação de informações desconhecidas com base nos dados usados para treiná-las.

Classificar dados treinando sua própria rede neural ​

Introdução ​

Requisitos ​

Criação de Arquivos ​

Execução do Código ​

Classificar dados treinando sua própria rede neural

Introdução

Requisitos

Criação de Arquivos

Execução do Código