Use as TPUs do Coral Edge para executar modelos do TFlite em Node com o TensorFlow.js.

1. Introdução

Última atualização: 11/04/2022

Neste codelab, você vai aprender a treinar um modelo de classificação de imagens usando a Máquina que Aprende e a executá-lo com a aceleração de hardware Coral usando o TensorFlow.js, uma biblioteca de machine learning avançada e flexível para JavaScript. Você vai criar um aplicativo Electron que exibe imagens de uma webcam e classificá-las usando uma TPU Edge Coral. Uma versão totalmente funcional deste codelab está disponível no repositório sig-tfjs do GitHub.

Preciso de um dispositivo coral?

Não. Você pode testar este codelab sem um dispositivo Coral e ainda ter um bom desempenho em uma máquina desktop usando o acelerador WebNN.

O que você vai criar

Neste codelab, você vai criar um app Electron que classifica imagens. Seu app:

• Classifica imagens da webcam nas categorias definidas no modelo que você treinou.
• Usa um acelerador coral para aumentar o desempenho, se houver um disponível.
• Usa o WebNN para aumentar o desempenho, caso seja compatível com sua plataforma.

O que você vai aprender

• Como instalar e configurar o pacote do NPM tfjs-tflite-node para executar modelos do TFLite no Node.js.
• Como instalar a biblioteca do ambiente de execução do Edge TPU para executar modelos em um dispositivo Coral.
• Como acelerar a inferência de modelo usando uma TPU de borda do Coral.
• Como acelerar a inferência de modelo com o WebNN.

Este codelab se concentra no TFLite em Node.js. Conceitos não relevantes e blocos de código são citados rapidamente e fornecidos para que você simplesmente os copie e cole.

O que é necessário

Para concluir este codelab, você precisa ter:

• Um computador com uma webcam.
• Para o Coral, recomendamos um Raspberry Pi com o SO Raspberry Pi (64 bits) no computador.
• Para a WebNN, recomendamos uma máquina Intel x86-64 com o Ubuntu 20.04 ou o Windows 10.
• Versão 12 ou mais recente do Node.js
• Conhecimento sobre JavaScript.
• (Recomendado) Use o Coral USB Accelerator para acelerar o modelo.

2. Começar a configuração

Buscar o código

Colocamos todo o código que você precisa para este projeto em um repositório Git. Para começar, abra o código no seu ambiente de desenvolvimento favorito. Neste codelab, recomendamos o uso de um Raspberry Pi com o SO Raspberry Pi (64 bits) no computador. Isso facilita a conexão de um acelerador Coral.

Recomendado: use o Git para clonar o repositório em um Raspberry Pi

Para conseguir o código, abra uma nova janela do terminal e clone o repositório:

git clone https://github.com/tensorflow/sig-tfjs.git

Todos os arquivos que você precisa editar para o codelab estão no diretório tfjs-tflite-node-codelab (dentro de sig-tfjs). Nele, você vai encontrar subdiretórios com os nomes starter_code, cpu_inference_working, coral_inference_working e webnn_inference_working. Estes são pontos de verificação para as etapas deste codelab.

Entre os outros arquivos no repositório estão os pacotes NPM de que tfjs-tflite-node-codelab depende. Não é necessário editar nenhum desses arquivos, mas você precisa executar alguns dos testes para verificar se o ambiente está configurado corretamente.

Instalar a biblioteca de ambiente de execução do Edge TPU

Os dispositivos Coral exigem que você instale a biblioteca de ambiente de execução do Edge TPU antes do uso. Para instalar, siga as instruções para sua plataforma.

No Linux / Raspberry Pi

No Linux, a biblioteca está disponível no PPA do Google como um pacote Debian, libedgetpu1-std, para arquiteturas x86-64 e Armv8 (64 bits). Se o processador usar uma arquitetura diferente, será necessário compilá-lo a partir da origem.

Execute este comando para adicionar o Coral PPA do Google e instalar a biblioteca do Edge TPU Runtime.

# None of this is needed on Coral boards
# This repo is needed for almost all packages below
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
# This repo is needed for only python3-coral-cloudiot and python3-coral-enviro
echo "deb https://packages.cloud.google.com/apt coral-cloud-stable main" | sudo tee /etc/apt/sources.list.d/coral-cloud.list

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

sudo apt-get update
sudo apt-get install libedgetpu1-std

No Windows / outros sistemas operacionais

Os binários pré-compilados estão disponíveis para versões x86-64 do MacOS e do Windows e podem ser instalados executando o script install.sh ou install.bat no arquivo após o download.

Reiniciar o dispositivo

Depois que o Edge TPU Runtime for instalado, reinicie o dispositivo para ativar a nova regra Coral Udev adicionada pelo instalador.

Verifique se o dispositivo Coral foi detectado

Para verificar se o dispositivo Coral foi detectado e está funcionando, execute os testes de integração com o pacote coral-tflite-delegate (link em inglês). Esse pacote é encontrado no diretório raiz do repositório. Para executar os testes de integração, conecte seu acelerador Coral e execute estes comandos no diretório do pacote:

npx yarn
npx yarn build-deps
npx yarn test-integration

Observação: se npx não estiver disponível, verifique se você instalou o Node.js. Para instalar o Node, siga as instruções em nodejs.org. Certifique-se de instalar uma versão superior ou igual a 12. A execução de apt install nodejs pode instalar o Node 10, que não será usado neste codelab.

O resultado deve ser parecido com este:

yarn run v1.22.17
$ yarn build && yarn test-integration-dev
$ tsc
$ jasmine --config=jasmine-integration.json
Platform node has already been set. Overwriting the platform with node.
Randomized with seed 78904
Started

============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
WARNING: converting 'int32' to 'uint8'
.


1 spec, 0 failures
Finished in 2.777 seconds
Randomized with seed 78904 (jasmine --random=true --seed=78904)
Done in 6.36s.

Não se preocupe em instalar @tensorflow/tfjs-node,, como mencionado nos registros, porque você executará o modelo no TFLite.

Se, em vez disso, a saída contiver Encountered unresolved custom op: edgetpu-custom-op, isso significa que o dispositivo Coral não foi detectado. Confirme se você instalou a biblioteca do ambiente de execução do Edge TPU e conectou o dispositivo Coral ao computador. Siga também o guia de iniciação do Coral (em inglês) para testar a versão Python das vinculações do Coral. Se a versão do Python funcionar, mas os testes ainda falharem, preencha um relatório do bug para nos informar.

Executar o código inicial

Agora está tudo pronto para executar o código inicial. Siga estas etapas para começar.

1. Acesse o diretório starter_code no diretório tfjs-tflite-node-codelab.
2. executar npm install para instalar dependências.
3. Execute npm start para iniciar o projeto. Um app que mostra um feed de vídeo da webcam do seu computador será aberto.

Observação:se você estiver usando uma placa de desenvolvimento Coral e o npm install gerar um erro ENOMEM, execute npm rebuild && npm install para recriar os pacotes corrompidos.

Qual é nosso ponto de partida?

Nosso ponto de partida é um app de câmera Electron básico, projetado para este codelab. O código foi simplificado para mostrar os conceitos do codelab e tem pouco tratamento de erros. Se você decidir reutilizar qualquer código em um app de produção, não deixe de processar todos os erros e testar todo o código.

Explorar o código inicial

Há muitos arquivos neste código inicial, mas o único que você precisa editar é renderer.js. Ele controla o que aparece na página, incluindo o feed de vídeo e os elementos HTML, e é onde você adiciona seu modelo de machine learning ao app. Entre os outros arquivos está um arquivo index.html, mas ele só carrega o arquivo renderer.js. Há também um arquivo main.js, que é o ponto de entrada para o Electron. Ele controla o ciclo de vida do app, incluindo o que mostrar quando aberto e o que fazer quando estiver fechado, mas você não precisa fazer nenhuma mudança nele.

Abrir o depurador

Talvez seja necessário depurar o app conforme este codelab. Como este app é baseado no Electron, ele tem o depurador do Chrome integrado. Na maioria das plataformas, você pode abrir com Ctrl + Shift + i. Clique na guia Console para ver os registros e as mensagens de erro do app.

Não há muito mais para explorar aqui, então vamos direto ao treinamento do classificador de imagens.

3. Treinar um classificador de imagens

Nesta seção, você vai treinar as versões TFLite e Coral de um modelo de classificação de imagem personalizado.

Treinar o classificador

Um classificador de imagem recebe imagens de entrada e atribui rótulos a elas. Neste codelab, você vai usar a Máquina que Aprende para treinar um modelo no navegador. Para acelerar o treinamento desta seção, você pode usar um computador desktop ou laptop em vez de um Raspberry Pi, mas terá que copiar os arquivos resultantes para o Pi.

Agora você já pode treinar um modelo. Se você não souber que tipo de modelo treinar, um modelo fácil de treinar é um detector de pessoas, que apenas detecta se uma pessoa está enquadrada.

1. Abra a página de treinamento da Máquina que Aprende em uma nova guia.
2. Selecione Projeto de imagem e depois Modelo de imagem padrão.
3. Adicione amostras de imagens para cada classe. Usar a entrada da webcam é a maneira mais fácil de fazer isso. Também é possível renomear as classes.
4. Após coletar dados suficientes para cada classe (50 amostras geralmente são suficientes), pressione Treinar modelo.

Quando o treinamento do modelo terminar, uma prévia da saída do modelo vai aparecer.

Tente inserir entradas diferentes no modelo. Se você encontrar uma entrada classificada incorretamente, adicione-a aos dados de treinamento e treine novamente o modelo.

5. Quando estiver satisfeito com a acurácia do modelo, clique em Exportar modelo. Você precisará fazer o download de duas versões separadas do modelo.
6. Exporte o modelo como um modelo de ponto flutuante do Tensorflow Lite. Será feito o download de um arquivo chamado converted_tflite.zip. que é executada na CPU.
7. Exporte o modelo como um modelo do EdgeTPU do Tensorflow Lite. Será feito o download de um arquivo chamado converted_edgetpu.zip, que será executado na TPU do Coral Edge.

Dica:para melhor precisão, use diversas rotações, posições e planos de fundo nas amostras de imagens. Use um laptop, se tiver, para coletar essas amostras com mais facilidade.

4. Executar o modelo de CPU no app

Agora que você treinou um modelo, é hora de adicioná-lo ao app. Ao final desta seção, o app poderá executar seu modelo usando a CPU do dispositivo.

Adicionar o arquivo de modelo ao app

Descompacte o arquivo do modelo converted_tflite.zip que você transferiu por download quando treinou o classificador. Há dois arquivos no arquivo. model_uquant.tflite é o modelo TFLite salvo, incluindo o grafo e os pesos do modelo. labels.txt contém os rótulos legíveis por humanos para as classes que o modelo prevê. Coloque os dois arquivos no modeldirectory.

Instalar dependências

O carregamento de um modelo e as entradas de pré-processamento exigem algumas dependências do TensorFlow.js:

• tfjs-tflite-node: pacote do TensorFlow.js para executar modelos do TFLite no Node.js.
• @tensorflow/tfjs: o pacote principal do TensorFlow.js.

O @tensorflow/tfjs já está instalado, mas você precisa instalar tfjs-tflite-node com este comando:

npm install --save tfjs-tflite-node

Depois da instalação, adicione-o ao app na parte superior de renderer.js:

CODELAB parte 1: importar o tfjs-tflite-node.

const {loadTFLiteModel} = require('tfjs-tflite-node');

Carregar o modelo

Agora está tudo pronto para carregar o modelo. O tfjs-tflite-node fornece a função loadTFLiteModel para fazer isso. Ele pode carregar modelos de um caminho de arquivo, um ArrayBuffer ou um URL do TFHub. Para carregar seu modelo e os respectivos pesos, adicione isto à função main:

CODELAB parte 1: carregue o modelo aqui.

const modelPath = './model/model_unquant.tflite';
const model = await loadTFLiteModel(modelPath);
const labels = fs.readFileSync('./model/labels.txt', 'utf8')
      .split('\n');

Executar o modelo

A execução do modelo tem três etapas. Primeiro, extraia e pré-processe um frame de entrada da webcam. Depois, você executa o modelo nesse frame e recebe uma previsão. Depois disso, você exibirá a previsão na página.

Pré-processar a entrada da webcam

No momento, a webcam é apenas um elemento HTML, e os frames exibidos não estão disponíveis para o arquivo renderizador.js do JavaScript. Para extrair frames da webcam, o TensorFlow.js oferece a tf.data.webcam, que oferece um método capture() fácil de usar para capturar frames da câmera.

Para usá-la, adicione este código de configuração ao arquivo main():

CODELAB parte 1: configure o tf.data.webcam aqui.

const tensorCam = await tf.data.webcam(webcam);

Em seguida, para capturar uma imagem a cada frame, adicione o seguinte a run():

CODELAB parte 1: capture frames da webcam aqui.

const image = await tensorCam.capture();

Você também precisa pré-processar cada frame para ser compatível com o modelo. O modelo usado neste codelab tem a forma de entrada [1, 224, 224, 3], então ele espera uma imagem RGB de 224 por 224 pixels. tensorCam.capture() dá uma forma de [224, 224, 3], então é preciso adicionar uma dimensão extra na frente do tensor com tf.expandDims. Além disso, o modelo de CPU espera uma entrada Float32 entre -1 e 1, mas a webcam captura valores de 0 a 255. Você pode dividir o tensor de entrada por 127 para alterar o intervalo dele de [0, 255] a [0, ~2] e, em seguida, subtrair 1 para chegar ao intervalo desejado [-1, ~1]. Adicione estas linhas a tf.tidy() na função run() para fazer isso:

CODELAB parte 1: pré-processe frames da webcam aqui.

const expanded = tf.expandDims(image, 0);
const divided = tf.div(expanded, tf.scalar(127));
const normalized = tf.sub(divided, tf.scalar(1));

É importante descartar os tensores depois de usá-los. tf.tidy() faz isso automaticamente para o código contido no callback, mas não é compatível com funções assíncronas. Será necessário descartar manualmente o tensor de imagem criado anteriormente chamando o método dispose() dele.

CODELAB parte 1: descarte os frames da webcam aqui.

image.dispose();

Executar o modelo e exibir os resultados

Para executar o modelo na entrada pré-processada, chame model.predict() no tensor normalizado. Isso retorna um tensor unidimensional contendo a probabilidade prevista de cada rótulo. Multiplique essa probabilidade por 100 para chegar à chance percentual de cada rótulo e use a função showPrediction incluída no código inicial para mostrar a previsão do modelo na tela.

Esse código também usa stats.js para cronometrar quanto tempo a previsão leva, colocando chamadas para stats.begin e stats.end em torno de model.predict.

CODELAB parte 1: execute o modelo e mostre os resultados aqui.

stats.begin();
const prediction = model.predict(normalized);
stats.end();
const percentage = tf.mul(prediction, tf.scalar(100));
showPrediction(percentage.dataSync(), labels);

Execute o app novamente com yarn start para ver as classificações do modelo.

Desempenho

Com a configuração atual, o modelo é executado na CPU. Isso é bom para computadores desktop e para a maioria dos laptops, mas pode não ser desejável se você o executar em um Raspberry Pi ou outro dispositivo de baixa energia. Em um Raspberry Pi 4, você provavelmente terá cerca de 10 QPS, o que pode não ser rápido o suficiente para alguns aplicativos. Para ter um melhor desempenho sem usar uma máquina mais rápida, você pode usar silício específico para aplicativos na forma de uma TPU Coral Edge.

5. Executar o modelo Coral no seu app

Se você não tiver um dispositivo Coral, pule esta seção.

Esta etapa do codelab se baseia no código que você escreveu na última seção, mas você pode usar o checkpoint cpu_inference_working se quiser começar do zero.

As etapas para executar o modelo Coral são quase idênticas às etapas para executar o modelo de CPU. A principal diferença é o formato do modelo. Como o Coral só aceita tensores uint8, o modelo é quantizado. Isso afeta os tensores de entrada passados para o modelo e os tensores de saída que ele retorna. Outra diferença é que os modelos precisam ser compilados usando o compilador Edge TPU para serem executados em uma TPU Coral. O TeachableMachine já fez essa etapa, mas acesse a documentação da Coral (em inglês) para aprender a fazer isso em outros modelos.

Adicionar o arquivo de modelo do Coral ao app

Descompacte o arquivo de modelo converted_edgetpu.zip que você transferiu por download quando treinou o classificador. Há dois arquivos incluídos no arquivo. model_edgetpu.tflite é o modelo TFLite salvo, incluindo o grafo e os pesos do modelo. labels.txt contém os rótulos legíveis por humanos para as classes que o modelo prevê. Coloque o arquivo do modelo no diretório coral_model.

Instalar dependências

A execução de modelos do Coral requer a biblioteca de ambiente de execução do Edge TPU. Antes de continuar, siga as instruções de configuração para verificar se você o instalou.

Os dispositivos Coral são acessados como delegados do TFLite. Para acessá-los no JavaScript, instale o pacote coral-tflite-delegate:

npm install --save coral-tflite-delegate

Em seguida, importe o delegado adicionando esta linha à parte superior do arquivo renderer.js:

CODELAB parte 2: importe o delegado aqui.

const {CoralDelegate} = require('coral-tflite-delegate');

Carregar o modelo

Agora está tudo pronto para carregar o modelo Coral. Faça isso da mesma forma que para o modelo da CPU, mas agora transmita opções à função loadTFLiteModel para carregar o delegado do Coral.

CODELAB parte 2: carregue o modelo delegado aqui.

const coralModelPath = './coral_model/model_edgetpu.tflite';
const options = {delegates: [new CoralDelegate()]};
const coralModel = await loadTFLiteModel(coralModelPath, options);

Não é preciso carregar os rótulos porque eles são os mesmos do modelo da CPU.

Adicione um botão para alternar entre CPU e Coral

Você vai adicionar o modelo Coral junto com o modelo de CPU incluído na última seção. Executar os dois ao mesmo tempo dificulta a visualização das diferenças de desempenho. Por isso, um botão alterna entre a execução de Coral e da CPU.

Adicione o botão com este código:

CODELAB parte 2: crie o botão delegado aqui.

let useCoralDelegate = false;
const toggleCoralButton = document.createElement('button');
function toggleCoral() {
  useCoralDelegate = !useCoralDelegate;
  toggleCoralButton.innerText = useCoralDelegate
      ? 'Using Coral. Press to switch to CPU.'
      : 'Using CPU. Press to switch to Coral.';
}
toggleCoralButton.addEventListener('click', toggleCoral);
toggleCoral();
document.body.appendChild(toggleCoralButton);

Vamos vincular essa condição à função run(). Quando useCoralDelegate for falso, ele executará a versão da CPU. Caso contrário, ele vai executar a versão Coral, mas, por enquanto, não vai fazer nada. Encapsule o código da execução do modelo de CPU em uma instrução if. O tensor expanded é deixado de fora da instrução "if" porque ele é usado pelo modelo Coral.

CODELAB parte 2: confira se o delegado deve ser usado neste link.

// NOTE: Don't just copy-paste this code into the app.
// You'll need to edit the code from the CPU section.
const expanded = tf.expandDims(image, 0);
if (useCoralDelegate) {
  // CODELAB part 2: Run Coral prediction here.
} else {
  const divided = tf.div(expanded, tf.scalar(127));
  const normalized = tf.sub(divided, tf.scalar(1));
  stats.begin();
  const prediction = model.predict(normalized);
  stats.end();
  const percentage = tf.mul(prediction, tf.scalar(100));
  showPrediction(percentage.dataSync(), labels);
}

Executar o modelo

A versão Coral do modelo espera tensores uint8 de 0 a 255, portanto, sua entrada não precisa ser normalizada. No entanto, a saída também é um tensor uint8 no intervalo de 0 a 255. Ele precisa ser convertido em um valor flutuante de 0 a 100 antes de ser exibido.

CODELAB parte 2: execute a previsão dos corais aqui. Isso faz parte do snippet de código acima.

stats.begin();
const prediction = coralModel.predict(expanded);
stats.end();
const percentage = tf.div(tf.mul(prediction, tf.scalar(100)), tf.scalar(255));
showPrediction(percentage.dataSync(), labels);

Execute o app novamente com yarn start para que ele mostre as classificações do acelerador Coral.

É possível alternar entre a inferência de Coral e de CPU pressionando o botão. As classificações de confiança do modelo Coral são menos precisas do que as do modelo de CPU e, em geral, terminam com uma casa decimal. Essa perda de precisão é uma compensação pela execução de um modelo quantizado na Coral. Na prática, isso geralmente não importa, mas é algo a ter em mente.

Uma observação sobre o desempenho

O frame rate que você vê inclui pré e pós-processamento, então não representa os recursos do hardware Coral. Para ter uma ideia melhor do desempenho, clique no medidor de QPS até que ele mostre a latência (em milissegundos), que mede apenas a chamada para model.predict. No entanto, isso ainda inclui o tempo necessário para mover os tensores para as vinculações C nativas do TFLite e depois para o dispositivo Coral, de modo que essa não é uma medida perfeita. Para comparativos de mercado de desempenho mais precisos escritos em C++, consulte a página de comparativo de mercado do EdgeTPU.

É importante ressaltar que o vídeo foi gravado em um laptop em vez de em um Raspberry Pi. Por isso, o QPS pode ser diferente.

Como acelerar o pré-processamento do Coral

Em alguns casos, é possível acelerar o pré-processamento alternando back-ends do TFJS. O back-end padrão é WebGL, que é bom para operações grandes e carregáveis em paralelo. No entanto, esse app não faz muito disso na fase de pré-processamento. A única operação usada é expandDims, que não é paralela. Para evitar a latência extra da movimentação de tensores de e para a GPU, alterne para o back-end da CPU adicionando essa linha após as importações na parte de cima do arquivo.

tf.setBackend(‘cpu');

Isso também afeta o pré-processamento do modelo de CPU do TFLite, que é carregado em paralelo. Com essa alteração, o modelo será muito mais lento.

6. Acelerar o modelo de CPU com o WebNN

Se você não tiver um acelerador de coral ou se quiser apenas testar outra maneira de acelerar o modelo, use o delegado WebNN TFLite. Esse delegado usa hardware de aprendizado de máquina integrado a processadores Intel para acelerar a inferência de modelos com o kit de ferramentas OpenVINO (link em inglês). Por isso, ele tem outros requisitos que não foram abordados na seção de configuração deste codelab, e você precisará instalar o kit de ferramentas OpenVINO. Verifique sua configuração em relação às plataformas de sistema de destino compatíveis antes de continuar, mas observe que o delegado da WebNN ainda não é compatível com macOS.

Instalar o kit de ferramentas OpenVINO

O kit de ferramentas OpenVINO usa hardware de aprendizado de máquina integrado a processadores Intel para acelerar modelos. Você pode fazer o download de uma versão pré-compilada da Intel ou compilá-la a partir da origem (links em inglês). Há várias maneiras de instalar o OpenVINO, mas para os fins deste codelab, recomendamos o uso do script de instalação para Windows ou Linux. Instale a versão do ambiente de execução LTS 2021.4.2, já que outras versões podem não ser compatíveis. Após executar o instalador, configure as variáveis de ambiente do shell conforme descrito nas instruções de instalação para Linux ou Windows ( solução permanente) ou executando o comando setupvars.sh (Linux) ou setupvars.bat (Windows) localizado no diretório webnn-tflite-delegate.

Observação do Windows: o comando setupvars.bat não é compatível com o Git bash. Portanto, execute-o e outros comandos deste codelab no prompt de comando do Windows.

Verificar se o delegado do WebNN está funcionando

Para verificar se o delegado da WebNN está funcionando corretamente, execute os testes de integração para o pacote webnn-tflite-delegate (link em inglês) encontrado no diretório raiz do repositório. Para executar os testes de integração, execute estes comandos no diretório do pacote:

# In webnn-tflite-delegate/
npx yarn
npx yarn test-integration

O resultado deve ser parecido com este:

WebNN delegate: WebNN device set to 0.
INFO: Created TensorFlow Lite WebNN delegate for device Default and power Default.

============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
label: wine bottle
score:  0.934505045413971
.


1 spec, 0 failures
Finished in 0.446 seconds
Randomized with seed 58441 (jasmine --random=true --seed=58441)
Done in 8.07s.

Uma resposta como esta indica um erro de configuração:

Platform node has already been set. Overwriting the platform with node.
Randomized with seed 05938
Started
error Command failed with exit code 3221225477.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

Essa saída provavelmente significa que você não definiu as variáveis de ambiente do OpenVINO. Por enquanto, você pode defini-las executando o comando setupvars.sh (Linux) ou setupvars.bat (Windows), mas convém configurá-las permanentemente seguindo as instruções para Linux ou Windows ( solução permanente). Se você estiver usando o Windows, a

setupvars.bat

O comando não é compatível com o Git bash, então ele e outros comandos deste codelab precisam ser executados no prompt de comando do Windows.

Instalar o delegado WebNN

Com o OpenVINO instalado, está tudo pronto para acelerar o modelo de CPU com o WebNN. Esta seção do codelab se baseia no código que você escreveu no curso "Executar o modelo de CPU no seu app" nesta seção. Você pode usar o código que criou nesta etapa, mas se já tiver concluído a seção Coral, use o checkpoint cpu_inference_working para começar do zero.

A parte Node.js do delegado WebNN é distribuída em npmjs. Para instalá-lo, execute este comando:

npm install --save webnn-tflite-delegate

Em seguida, importe o delegado adicionando esta linha à parte superior do arquivo renderer.js:

CODELAB parte 2: importe o delegado aqui.

const {WebNNDelegate, WebNNDevice} = require('webnn-tflite-delegate');

O delegado WebNN é compatível com execução na CPU ou na GPU. WebNNDevice permite escolher qual usar.

Carregar o modelo

Agora está tudo pronto para carregar o modelo com o delegado da WebNN ativado. Para o Coral, era preciso carregar um arquivo de modelo diferente, mas a WebNN suporta o mesmo formato de modelo que o TFLite. Adicione o WebNNDelegate à lista de delegados transmitidos ao modelo para ativá-lo:

CODELAB parte 2: carregue o modelo delegado aqui.

let webnnModel = await loadTFLiteModel(modelPath, {
  delegates: [new WebNNDelegate({webnnDevice: WebNNDevice.DEFAULT})],
});

Não é preciso carregar os rótulos novamente porque esse é o mesmo modelo.

Adicione um botão para alternar entre a CPU do TfLite e o WebNN

Agora que a versão WebNN do modelo está pronta, adicione um botão para alternar entre a inferência de CPU WebNN e TfLite. Executar os dois ao mesmo tempo dificulta a visualização das diferenças de desempenho.

Adicione o botão com este código (ele ainda não muda de modelo):

CODELAB parte 2: crie o botão delegado aqui.

let useWebNNDelegate = false;
const divElem = document.createElement('div');
const toggleWebNNButton = document.createElement('button');
function toggleWebNN() {
  useWebNNDelegate = !useWebNNDelegate;
  toggleWebNNButton.innerHTML = useWebNNDelegate
      ? 'Using WebNN. Press to switch to TFLite CPU.'
      : 'Using TFLite CPU. Press to switch to WebNN.';
  divElem.hidden = useWebNNDelegate ? false : true;
}

toggleWebNNButton.addEventListener('click', toggleWebNN);
toggleWebNN();
document.body.appendChild(toggleWebNNButton);
document.body.appendChild(divElem);

Esse código também adiciona um elemento div que você usa para definir as configurações de WebNN na próxima seção.

Adicionar um menu suspenso para alternar entre dispositivos WebNN

A WebNN oferece suporte à execução em CPUs e GPUs, então adicione um menu suspenso para alternar entre elas. Adicione este código após o que cria o botão:

// Create elements for WebNN device selection
divElem.innerHTML = '<br/>WebNN Device: ';
const selectElem = document.createElement('select');
divElem.appendChild(selectElem);

const webnnDevices = ['Default', 'GPU', 'CPU'];
// append the options
for (let i = 0; i < webnnDevices.length; i++) {
  var optionElem = document.createElement('option');
  optionElem.value = i;
  optionElem.text = webnnDevices[i];
  selectElem.appendChild(optionElem);
}

Agora, se você executar o app, vai encontrar um menu suspenso que lista Padrão, GPU e CPU. A escolha de uma delas não tem efeito agora, já que o menu suspenso ainda não foi ativado.

Fazer o menu suspenso mudar o dispositivo

Para conectar o menu suspenso para que ele mude o dispositivo WebNN, adicione um listener ao evento change do elemento seletor do menu suspenso. Quando o valor selecionado mudar, recrie o modelo WebNN com o dispositivo WebNN correspondente selecionado nas opções de delegação.

Adicione o seguinte código após o que adicionou o menu suspenso:

selectElem.addEventListener('change', async () => {
  let webnnDevice;
  switch(selectElem.value) {
    case '1':
      webnnDevice = WebNNDevice.GPU;
      break;
    case '2':
      webnnDevice = WebNNDevice.CPU;
      break;
    default:
      webnnDevice = WebNNDevice.DEFAULT;
      break;
  }
  webnnModel = await loadTFLiteModel(modelPath, {
    delegates: [new WebNNDelegate({webnnDevice})],
  });
});

Com essa mudança, sempre que mudar, o menu suspenso vai criar um modelo com as configurações corretas. Agora é hora de conectar o modelo WebNN e usá-lo para inferência.

Executar o modelo WebNN

O modelo WebNN está pronto para uso, mas o botão para alternar entre a CPU WebNN e TfLite ainda não muda de modelo. Para alternar o modelo, primeiro é necessário renomear a variável model de quando você carregou o modelo de CPU do TfLite na primeira seção do codelab.

Altere a linha a seguir...

const model = await loadTFLiteModel(modelPath);

...para que ela corresponda a esta linha.

const cpuModel = await loadTFLiteModel(modelPath);

Com a variável model renomeada como cpuModel, adicione-a à função run para escolher o modelo correto com base no estado do botão:

CODELAB parte 2: confira se o delegado deve ser usado neste link.

let model;
if (useWebNNDelegate) {
  model = webnnModel;
} else {
  model = cpuModel;
}

Agora, quando você executar o app, o botão vai alternar entre a CPU do TfLite e o WebNN.

Também será possível alternar entre a CPU WebNN e a inferência se você tiver uma GPU Intel integrada.

Uma observação sobre o desempenho

O frame rate mostrado inclui pré e pós-processamento. Por isso, ele não representa os recursos da WebNN. Para ter uma ideia melhor do desempenho, clique no medidor de QPS até que ele mostre a latência (em milissegundos), que mede apenas a chamada para model.predict. No entanto, isso ainda inclui o tempo necessário para mover tensores para as vinculações C nativas do TFLite, de modo que não é uma medida perfeita.

7. Parabéns

Parabéns! Você acabou de concluir seu primeiro projeto Coral / WebNN usando tfjs-tflite-node no Electron.

Experimente e teste-o em diversas imagens. Também é possível treinar um novo modelo no TeachableMachine para classificar algo completamente diferente.

Resumo

Neste codelab, você aprendeu como:

• Como instalar e configurar o pacote NPM tfjs-tflite-node para executar modelos do TFLite no Node.js.
• Como instalar a biblioteca do ambiente de execução do Edge TPU para executar modelos em um dispositivo Coral.
• Como acelerar a inferência de modelo usando uma TPU de borda do Coral.
• Como acelerar a inferência de modelo com a WebNN.

Qual é a próxima etapa?

Agora que você tem uma base de trabalho para começar, quais ideias de criativos você pode ter para estender esse executor de modelos de machine learning a um caso de uso real em que talvez esteja trabalhando? Talvez você possa revolucionar o setor em que você trabalha com inferência rápida e acessível ou talvez modificar uma torradeira para que ela pare de torrar quando o pão estiver no lugar certo. As possibilidades são infinitas.

Para saber mais sobre como a TeachableMachine treinou o modelo que você usou, confira nosso codelab sobre aprendizado por transferência. Se você está procurando outros modelos que funcionam com o Coral, como reconhecimento de fala e estimativa de poses, consulte coral.ai/models. Você também encontra versões de CPU desses modelos e muitos outros no TensorFlow Hub.

Compartilhe o que você sabe conosco

É possível estender facilmente o que você criou hoje para outros casos de uso criativos também. Incentivamos você a pensar fora da caixa e continuar a inovar.

Não se esqueça de nos marcar nas redes sociais usando a hashtag #MadeWithTFJS para que seu projeto apareça no blog do TensorFlow ou em eventos futuros. Adoraríamos saber o que você faz.

Sites para conferir

• Site oficial do TensorFlow.js
• Modelos prontos do TensorFlow.js
• API TensorFlow.js
• Apresentação do TensorFlow.js e Diga