Acompanhe online o evento final da Maratona Behind the Code 2020 Inscreva-se já!

Uma introdução à Inteligência Artificial no Node.js

Os recentes avanços em inteligência artificial (IA) têm transformado diversos serviços e deverão ser pervasivos nos sistemas de computação em um futuro próximo. Muitas tarefas que antes exigiam interação ou conhecimento humano agora podem ser capturadas e automatizadas em modelos de aprendizado de máquina ou em modelos de deep learning. Neste tutorial, você obterá uma visão geral do uso de Inteligência Artificial nos aplicativos Node.js usando o TensorFlow.js.

Para percorrer essa linha de aprendizagem, deve-se obter o modelo de deep learning que executa as tarefas que o aplicativo exige. Há muitos modelos de software livre pré-treinados disponíveis para uso É possível encontrar vários deles no IBM Model Asset eXchange ou treinar seu próprio modelo.

Para os desenvolvedores, uma questão levada em consideração é como implementar os modelos de deep learning a serem usados pelos aplicativos. Há duas maneiras de implementar esses modelos:

  1. Como um serviço da web que pode ser acessado por meio de uma chamada da API no aplicativo
  2. Integrado ao próprio aplicativo

Observe que há outras maneiras de integrar a Inteligência Artificial no Node.js, como o TorchJS ou o ONNX.js, e cada um deles oferece diferentes níveis de suporte. Neste tutorial, abordaremos o TensorFlow.js porque ele oferece maior suporte ao cliente e ao servidor. Como nosso interesse é no Node.js, concentraremos em integrar os modelos a aplicativos Node.

Por que a Inteligência Artificial no JavaScript?

Embora os cientistas de dados prefiram o Python para o desenvolvimento de Inteligência Artificial, o JavaScript oferece várias vantagens tanto para o cliente quanto para o servidor:

  • A ampla comunidade de desenvolvedores JavaScript pode usar a Inteligência Artificial em grande escala com eficiência.
  • A área de cobertura menor e o tempo de início rápido do Node.js podem ser uma boa vantagem para implementações em contêineres e em dispositivos de IoT.
  • Os modelos de Inteligência Artificial processam voz, texto escrito e imagens, e quando eles são fornecidos na nuvem, os dados precisam ser enviados a um servidor remoto. A privacidade de dados tornou-se uma preocupação significativa recentemente, portanto, a capacidade de executar o modelo localmente no cliente com JavaScript pode ajudar a aliviar essa preocupação.
  • A execução local de um modelo no cliente pode ajudar a deixar os aplicativos de navegador mais interativos.

O que é o TensorFlow.js?

O TensorFlow.js é uma biblioteca de software livre para os desenvolvedores JavaScript criarem e usarem modelos de aprendizado de máquina ou de deep learning diretamente no navegador ou em um aplicativo Node.js. O TensorFlow é o software livre mais abrangente, que inclui suporte para diferentes linguagens de programação, como Python, e diferentes plataformas, como servidor, móvel e IoT.

Com o TensorFlow.js, é possível:

  • Criar modelos facilmente e treiná-los desde o início.
  • Reutilizar um modelo que já foi pré-treinado. Para o Node.js especificamente, um modelo pode ser escrito em Python para usar a capacidade de treinamento distribuída em grandes conjuntos de dados. Em seguida, o modelo treinado pode ser carregado e usado em um aplicativo Node.js.
  • Usar a GPU para acelerar o processamento.

Pré-requisitos

Para seguir este tutorial, é necessário ter:

Tempo estimado

Deve levar aproximadamente 30 minutos para concluir este tutorial.

Etapas

Neste tutorial, executaremos o seguinte para mostrar como é possível começar a usar a Inteligência Artificial no Node.js:

  1. Configurar um projeto Node do TensorFlow.js
  2. Executar um modelo empacotado
  3. Executar um modelo da web do TensorFlow.js

Configurar um projeto Node do TensorFlow.js

Antes de começar a usar o TensorFlow.js, primeiro assegure-se de que o ambiente esteja pronto para desenvolvimento. Se o Node.js ainda não estiver instalado, siga estas instruções para configurar um ambiente geral.

Para o editor de código, recomendamos o uso do Visual Studio Code, como mencionado no tutorial do Node.js. No entanto, fique à vontade para usar qualquer editor que desejar.

Crie um projeto

Agora, crie um projeto Node.js a ser usado no restante deste tutorial.

mkdir tfjs-project
cd tfjs-project
npm init -y
npm install @tensorflow/tfjs-node

Isso inicializa um novo projeto Node e instala o TensorFlow.js da CPU do pacote Node.js. No entanto, se você tiver uma máquina Linux ou Windows com uma GPU NVIDIA ativada para CUDA, será possível, como alternativa, instalar a versão da GPU.

npm install @tensorflow/tfjs-node-gpu

Note: Para a versão da GPU, também é necessário que o kit de ferramentas do CUDA e o SDK do cuDNN estejam instalados. É possível encontrar as versões necessárias neste link do TensorFlow no GitHub.

Neste tutorial, consideramos que você tenha instalado a versão da CPU @tensorflow/tfjs-node.

Execute um modelo gerenciado

Antes de aprofundar-se no tfjs e em suas APIs, há alguns recursos que fornecem modelos pré-treinados populares e APIs simplificadas para ajudá-lo a começar rapidamente. A equipe do TensorFlow.js na Google fornece vários modelos pré-treinados no repositório tfjs-models. Esses modelos pré-treinados são fornecidos em pacotes NPM com APIs fáceis de usar. A equipe do IBM Center for Open-source Data & AI Technologies (CODAIT) também fornece alguns modelos pré-treinados no repositório max-tfjs-models.

Neste tutorial, usamos o pacote Object Detection (COCO-SSD) @tensorflow-models/coco-ssd. Você usará suas APIs para identificar vários objetos em uma única imagem.

Crie um projeto

  1. Instale o pacote @tensorflow-models/coco-ssd no diretório tfjs-project que você já criou.

     npm install @tensorflow-models/coco-ssd
    
  2. Programe as seguintes tarefas no Node.js.

    1. Use as APIs predefinidas para carregar o modelo pré-treinado COCO-SSD.
    2. Use as APIs do tfjs-node para decodificar a imagem em um tf.Tensor3D.
    3. Passe a imagem tf.Tensor3D ao modelo carregado para inferência.
    4. Imprima as predições.
  3. Assegure-se de que você esteja dentro da pasta do projeto e, em seguida, copie e cole o código a seguir em um arquivo chamado index.js.

     const cocoSsd = require('@tensorflow-models/coco-ssd');
     const tf = require('@tensorflow/tfjs-node');
     const fs = require('fs').promises;
    
     // Load the Coco SSD model and image.
     Promise.all([cocoSsd.load(), fs.readFile('image1.jpg')])
     .then((results) => {
       // First result is the COCO-SSD model object.
       const model = results[0];
       // Second result is image buffer.
       const imgTensor = tf.node.decodeImage(new Uint8Array(results[1]), 3);
       // Call detect() to run inference.
       return model.detect(imgTensor);
     })
     .then((predictions) => {
       console.log(JSON.stringify(predictions, null, 2));
     });
    
  4. Para executar o modelo de detecção de objeto, é necessária uma imagem como entrada. Para obter uma imagem de teste, baixe esta imagem na pasta do projeto. É possível executar o programa usando o comando a seguir.

node .

Você usou um modelo de Object Detection com sucesso para reconhecer os objetos dentro de uma imagem. Agora, analise o código para entender melhor as partes.

Explicando o código

O uso de APIs predefinidas é simples. É possível consultar a documentação detalhada do pacote NPM COCO-SSD. Primeiro, usamos require() para obter o módulo COCO-SSD.

const cocoSsd = require('@tensorflow-models/coco-ssd');

Também precisamos de um decodificador de imagem, que está incluído no módulo tfjs-node. Consulte os detalhes nos documentos.

const tf = require('@tensorflow/tfjs-node');

Finalmente, precisamos do módulo fs para carregar o arquivo de imagem do sistema de arquivos. Como a maioria das APIs de COCO-SSD retornam objetos Promise em vez de usar retornos de chamada, também podemos usar as APIs de Promessa no módulo fs.

const fs = require('fs').promises

Depois de carregar todos os módulos necessários, será possível carregar o modelo pré-treinado COCO-SSD e o arquivo de imagem ao mesmo tempo.

Promise.all([cocoSsd.load(), fs.readFile('image1.jpg')])

cocoSsd.load() carrega o modelo pré-treinado, e fs.readFile() carrega a imagem. Os dois retornam objetos de Promessa, e os resultados são retornados na função de retorno de chamada then(). O primeiro objeto é a instância do modelo carregada, e o segundo objeto é o conteúdo da imagem como Buffer.

Em seguida, usamos as APIs do decodificador fornecidas pelo tfjs-node para decodificar os dados da imagem bruta em um objeto tf.Tensor3D. Os tensores são arrays n-dimensionais que agem como a estrutura de dados fundamental do TensorFlow para transferir e manipular dados.

const imgTensor = tf.node.decodeImage(new Uint8Array(results[1]), 3);

O tf.Tensor3D pode ser transmitido para detect() do loadedModel para inferência.

return model.detect(imgTensor);

O objeto return também é um objeto de Promessa, e seu objeto fulfill é a predição. Imprimimos a predição em um console.

console.log(JSON.stringify(predictions, null, 2));

Outros modelos pré-treinados

Há muitos módulos do TensorFlow.js predefinidos, e todos eles oferecem APIs semelhantes para carregar o modelo pré-treinado e executar a inferência. Geralmente, eles também fornecem as APIs de pré-processamento de dados para converter os dados brutos no formato de dados adequado. Em seguida, você transmite os dados processados para as funções de previsão.

Execute um modelo da web do TensorFlow.js

Na seção anterior, você executou um modelo do TensorFlow.js empacotado como um modelo NPM com uma API simples. O módulo cuida de todo o ciclo de vida do modelo. Ele carrega o modelo e executa o processamento nas entradas e saídas. Isso facilita o uso, permitindo a execução de tarefas de aprendizado de máquina com um conhecimento mínimo do modelo.

No entanto, talvez você prefira trabalhar com um modelo que não tenha sido empacotado em um módulo. Nesse caso, seria necessário carregar o modelo e processar os dados por conta própria. Nesta seção, será possível aprender como trabalhar com um modelo do TensorFlow.js. Você carregará um modelo e pré-processará os dados de entrada para o formato do tensor exigido pelo modelo. Também pode ser necessário pós-processar a saída do modelo para um formato mais compreensível.

O modelo usado nesta seção é o mesmo modelo que foi empacotado no módulo NPM COCO-SSD executado na seção anterior. O código apresentado aqui é uma versão modificada do código do módulo NPM.

Modelos do TensorFlow.js

O TensorFlow.js provides support for several model types:

  • tf.LayersModel: Isso é criado ao usar a API de Camadas do TensorFlow.js para criar um modelo. Ele também é produzido ao converter um modelo Keras com a ferramenta tensorflowjs_converter. Um LayersModel pode ser usado para treinar e fazer inferências.

  • tf.GraphModel: Isso é criado ao converter um SavedModel do TensorFlow com a ferramenta tensorflowjs_converter. Um GraphModel pode ser usado para fazer inferências, mas não para treinamento.

  • tf.node.TFSavedModel: No Node.js, o TensorFlow.js fornece suporte nativo para o SavedModel do TensorFlow. É possível carregar e executar um SavedModel no ambiente Node.js sem conversão. Atualmente, os SavedModels no Node.js são somente para fazer inferências e não para treinamento.

O tipo de modelo com o qual você está trabalhando determina a API usada para carregar e executar o modelo.

Carregando um modelo

Vários arquivos compõem a definição de um modelo, seja ele um GraphModel ou um LayersModel. Encontre o arquivo (model.json) que contém o gráfico de fluxo de dados e os shards de arquivos binários de ponderação. Para usar um modelo, deve-se chamar a API apropriada e fornecer a URL ou o caminho para o arquivo model.json.

Também é possível carregar modelos do Hub do TensorFlow fornecendo a URL do Hub do TensorFlow e incluindo a opção fromTFHub configurada como true.

Para este exercício, é possível usar a versão hospedada no Hub do TensorFlow para carregar o modelo COCO-SSD. Como esse é um SavedModel do TensorFlow convertido, seria necessário carregá-lo com a API do GraphModel.

Agora, vamos escrever os códigos para carregar o modelo.

  1. Crie um novo arquivo chamado run-tfjs-model.js no tfjs-project que você já havia criado.
  2. Inclua o código a seguir nesse arquivo.

     const tf = require('@tensorflow/tfjs-node');
    
     const modelUrl = 'https://tfhub.dev/tensorflow/tfjs-model/ssdlite_mobilenet_v2/1/default/1';
    
     let model;
    
     // load COCO-SSD graph model from TensorFlow Hub
     const loadModel = async function () {
       console.log(`loading model from ${modelUrl}`);
    
       model = await tf.loadGraphModel(modelUrl, {fromTFHub: true});
    
       return model;
     }
    
     // run
     loadModel().then(model => {
       console.log(model);
     })
    
  3. Execute o aplicativo.

     node run-tfjs-model.js
    

Depois de executar o aplicativo, é possível encontrar algumas informações sobre o modelo TensorFlow.js carregado no log do console.

Pré-processamento de entrada

Para executar uma inferência no modelo, deve-se fornecer uma imagem como entrada. Como o modelo espera um Tensor quadridimensional de valores de pixel de uma imagem, ela deve ser processada no Tensor com o formato apropriado para que possa ser passada ao modelo.

Incluiremos alguns códigos para converter uma imagem usando a API tf.node.decodeImage. Em seguida, aumentaremos o Tensor tridimensional para quatro dimensões com tf.expandDims.

  1. Inclua o código de pré-processamento a seguir no arquivo run-tfjs-model.js.

     const fs = require('fs');
    
     // convert image to Tensor
     const processInput = function (imagePath) {
       console.log(`preprocessing image ${imagePath}`);
    
       const image = fs.readFileSync(imagePath);
       const buf = Buffer.from(image);
       const uint8array = new Uint8Array(buf);
    
       return tf.node.decodeImage(uint8array, 3).expandDims();
     }
    
  2. Atualize o código run para permitir a passagem no caminho para um arquivo de imagem.

     // run
     if (process.argv.length < 3) {
       console.log('please pass an image to process. ex:');
       console.log('  node run-tfjs-model.js /path/to/image.jpg');
     } else {
       // e.g., /path/to/image.jpg
       let imagePath = process.argv[2];
    
       loadModel().then(model => {
         const inputTensor = processInput(imagePath);
         inputTensor.print();
       })
     }
    
  3. Execute o aplicativo.

     node run-tfjs-model.js image1.jpg
    

Ao executar o código, o modelo é carregado, a imagem é pré-processada e o tensor de imagem resultante é exibido.

Executando um modelo

Ao executar uma inferência em um modelo, há várias opções, dependendo do tipo de modelo. Todas as APIs de modelo fornecem uma função de previsão (ou seja, tf.GraphModel.predict, tf.LayersModel.predict e tf.node.TFSavedModel.predict). A função predict aceita os tensores de entrada e uma configuração de predição opcional.

Também há uma função execute, mas ela é suportada somente para o GraphModel e o SavedModel (por exemplo, tf.GraphModel.execute e tf.node.TFSavedModel.execute).

A função execute aceita os tensores de entrada e os nomes de nó de saída opcionais. Os nomes de nó de saída permitem a solicitação de tensores intermediários.

Para executar o modelo COCO-SSD e obter uma predição, passe o tensor da imagem para tf.GraphModel.executeAsync. Isso funciona como a função execute, mas de um modo assíncrono. Quando o modelo contém operações de fluxo de controle, deve-se usar executeAsync para evitar erros de tempo de execução.

  1. Inclua o código de pré-processamento a seguir no arquivo run-tfjs-model.js.

     // run prediction with the provided input Tensor
     const runModel = function (inputTensor) {
       console.log('runnning model');
    
       return model.executeAsync(inputTensor);
     }
    
  2. Atualize o código run para passar o tensor da imagem ao modelo e obter uma predição.

     // run
     if (process.argv.length < 3) {
       console.log('please pass an image to process. ex:');
       console.log('  node run-tfjs-model.js /path/to/image.jpg');
     } else {
       // e.g., /path/to/image.jpg
       let imagePath = process.argv[2];
    
       loadModel().then(model => {
         const inputTensor = processInput(imagePath);
         return runModel(inputTensor);
       }).then(prediction => {
         console.log(prediction);
       })
     }
    
  3. Execute o aplicativo.

     node run-tfjs-model.js image1.jpg
    

Com essas mudanças, o tensor da imagem é enviado ao modelo para que a inferência seja feita e a predição seja exibida.

Pré-processamento de saída

A predição retornada pelo modelo COCO-SSD é uma array com dois tensores. O primeiro tensor contém a pontuação de cada classe para cada caixa delimitadora encontrada. O segundo tensor contém as coordenadas de cada caixa delimitadora encontrada. Esses tensores precisam de um processamento para que sejam representados de forma mais significativa. O processamento computa as caixas delimitadores, as pontuações e os rótulos da predição.

  1. Inclua uma função auxiliar para extrair a classe e a pontuação. Observe o uso de dataSync() para o tensor de entrada. É assim que colocamos os valores do tensor em uma TypedArray que pode ser usada com o JavaScript regular. A constante scores acaba sendo uma Float32Array comprimida contendo todas as pontuações de classe possíveis para cada caixa delimitadora. O objetivo aqui é passar por essa array e, para cada caixa delimitadora, determinar qual classe tem a pontuação mais alta.

     // determine the classes and max scores from the prediction
     const extractClassesAndMaxScores = function (predictionScores) {
       console.log('calculating classes & max scores');
    
       const scores = predictionScores.dataSync();
       const numBoxesFound = predictionScores.shape[1];
       const numClassesFound = predictionScores.shape[2];
    
       const maxScores = [];
       const classes = [];
    
       // for each bounding box returned
       for (let i = 0; i < numBoxesFound; i++) {
         let maxScore = -1;
         let classIndex = -1;
    
         // find the class with the highest score
         for (let j = 0; j < numClassesFound; j++) {
           if (scores[i * numClassesFound + j] > maxScore) {
             maxScore = scores[i * numClassesFound + j];
             classIndex = j;
           }
         }
    
         maxScores[i] = maxScore;
         classes[i] = classIndex;
       }
    
       return [maxScores, classes];
     }
    
  2. Inclua uma função auxiliar para executar uma supressão não máxima (NMS) de caixas delimitadoras. Essa é uma técnica para assegurar que um determinado objeto seja identificado somente uma vez.

     const maxNumBoxes = 5;
    
     // perform non maximum suppression of bounding boxes
     const calculateNMS = function (outputBoxes, maxScores) {
       console.log('calculating box indexes');
    
       const boxes = tf.tensor2d(outputBoxes.dataSync(), [outputBoxes.shape[1], outputBoxes.shape[3]]);
       const indexTensor = tf.image.nonMaxSuppression(boxes, maxScores, maxNumBoxes, 0.5, 0.5);
    
       return indexTensor.dataSync();
     }
    
  3. Inclua uma função auxiliar para criar o objeto JSON usando as caixas, as pontuações e as classes. O código faz referência ao arquivo labels.js. Esse arquivo contém um mapeamento dos rótulos de objeto para seus valores/IDs de índice retornados pelo modelo. Obtenha o arquivo labels.js e inclua esse arquivo no diretório de projeto.

     const labels = require('./labels.js');
    
     let height = 1;
     let width = 1;
    
     // create JSON object with bounding boxes and label
     const createJSONresponse = function (boxes, scores, indexes, classes) {
       console.log('create JSON output');
    
       const count = indexes.length;
       const objects = [];
    
       for (let i = 0; i < count; i++) {
         const bbox = [];
    
         for (let j = 0; j < 4; j++) {
           bbox[j] = boxes[indexes[i] * 4 + j];
         }
    
         const minY = bbox[0] * height;
         const minX = bbox[1] * width;
         const maxY = bbox[2] * height;
         const maxX = bbox[3] * width;
    
         objects.push({
           bbox: [minX, minY, maxX, maxY],
           label: labels[classes[indexes[i]]],
           score: scores[indexes[i]]
         });
       }
    
       return objects;
     }
    
  4. Inclua o seguinte código de processamento de saída.

     // process the model output into a friendly JSON format
     const processOutput = function (prediction) {
       console.log('processOutput');
    
       const [maxScores, classes] = extractClassesAndMaxScores(prediction[0]);
       const indexes = calculateNMS(prediction[1], maxScores);
    
       return createJSONresponse(prediction[1].dataSync(), maxScores, indexes, classes);
     }
    
  5. Atualize o código run para processar a predição.

     // run
     if (process.argv.length < 3) {
       console.log('please pass an image to process. ex:');
       console.log('  node run-tfjs-model.js /path/to/image.jpg');
     } else {
       // e.g., /path/to/image.jpg
       let imagePath = process.argv[2];
    
       loadModel().then(model => {
         const inputTensor = processInput(imagePath);
         height = inputTensor.shape[1];
         width = inputTensor.shape[2];
         return runModel(inputTensor);
       }).then(prediction => {
         const output = processOutput(prediction);
         console.log(output);
       })
     }
    
  6. Execute o aplicativo.

     node run-tfjs-model.js image1.jpg
    

Parabéns! Agora você tem um aplicativo TensorFlow.js em funcionamento que usa o Node.js. A entrada para o aplicativo é o caminho de um arquivo de imagem. A saída é um objeto JSON contendo cada objeto detectado, suas pontuações e suas localizações na imagem. O código a seguir mostra um exemplo.

[
  {
    bbox: [
      35.42379140853882,
      148.18407735228539,
      223.39171171188354,
      314.645888954401
    ],
    label: 'person',
    score: 0.9464929103851318
  },
  {
    bbox: [
      337.3498320579529,
      152.96796306967735,
      205.84774017333984,
      321.53918293118477
    ],
    label: 'person',
    score: 0.9131661653518677
  },
  {
    bbox: [
      181.7181944847107,
      44.92521911859512,
      212.15811967849731,
      423.26776707172394
    ],
    label: 'person',
    score: 0.7019169926643372
  }
]

Aprimoramentos adicionais (Opcional)

Se você deseja aprimorar ainda mais o aplicativo, é possível tentar desenhar as caixas delimitadoras e os rótulos na imagem. Existem várias abordagens e ferramentas para auxiliar nessa tarefa. Uma ferramenta é o módulo @codait/max-vis. Dada uma imagem e uma predição em formato JSON, ele tenta criar uma nova versão da imagem de entrada com a predição desenhada na imagem.

  1. Instale a ferramenta max-vis (por exemplo, npm install @codait/max-vis).
  2. Inclua o seguinte código de anotação max-vis no aplicativo.

     const maxvis = require('@codait/max-vis');
     const path = require('path');
    
     const annotateImage = function (prediction, imagePath) {
       console.log(`annotating prediction result(s)`);
    
       maxvis.annotate(prediction, imagePath)
         .then(annotatedImageBuffer => {
           const f = path.join(path.parse(imagePath).dir, `${path.parse(imagePath).name}-annotate.png`);
    
           fs.writeFile(f, annotatedImageBuffer, (err) => {
             if (err) {
               console.error(err);
             } else {
               console.log(`annotated image saved as ${f}\r\n`);
             }
           });
         })
     }
    
  3. Atualize o código run para anotar a resposta JSON.

     // run
     if (process.argv.length < 3) {
       console.log('please pass an image to process. ex:');
       console.log('   node run-tfjs-model.js /path/to/image.jpg');
     } else {
       // e.g., /path/to/image.jpg
       let imagePath = process.argv[2];
    
       loadModel().then(model => {
         const inputTensor = processInput(imagePath);
         height = inputTensor.shape[1];
         width = inputTensor.shape[2];
         return runModel(inputTensor);
       }).then(prediction => {
         const jsonOutput = processOutput(prediction);
         console.log(jsonOutput);
         annotateImage(jsonOutput, imagePath);
       })
     }
    

A execução com esse código adicional resulta em uma nova imagem anotada. A nova imagem é criada e salva no mesmo diretório que a imagem de origem.

Três astronautas identificados como pessoas. Cada um marcado com uma cor diferente

É possível obter o aplicativo Node.js completo (run-tfjs-model.js).

Conclusão

Neste tutorial, você aprendeu como o JavaScript pode ser usado como uma ferramenta para o desenvolvimento de Inteligência Artificial com o TensorFlow.js. Você viu como é possível utilizar recursos de Inteligência Artificial em um aplicativo Node.js usando dois métodos:

  1. Usando um módulo do TensorFlow.js predefinido com uma API simples
  2. Usando a API do TensorFlow.js para carregar o modelo diretamente e executando as etapas de pré e pós-processamento necessárias para obter a saída desejada.

Nesse exemplo, usamos um modelo de detecção de objeto e pudemos criar aplicativos do Node que conseguem identificar objetos e suas localizações em uma imagem. Na próxima parte da série, entraremos em mais detalhes sobre os conceitos relacionados a deep learning e percorreremos os modelos de construção desde o início. Tudo em JavaScript.

Vídeo

Aviso

O conteúdo aqui presente foi traduzido da página IBM Developer US. Caso haja qualquer divergência de texto e/ou versões, consulte o conteúdo original.