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

1. Introdução

54e81d02971f53e8.png

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

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

Preciso de um dispositivo de corais?

Não. Você pode testar este codelab sem um dispositivo Coral e ainda conseguir um bom desempenho em um computador desktop usando o acelerador WebNN.

O que você criará

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

  • Classifica as imagens da webcam de acordo com as categorias definidas no modelo treinado.
  • Usa um acelerador de corais para melhorar o desempenho, se houver um disponível.
  • Usa WebNN para melhorar o desempenho, se for compatível com sua plataforma.

O que você aprenderá

  • Como instalar e configurar o pacote NPM tfjs-tflite-node para executar modelos do TFLite em Node.js.
  • Como instalar a biblioteca de tempo de execução da 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.

Este codelab se concentra no TFLite no Node.js. Conceitos e blocos de códigos sem relevância serão resumidos e apresentados para que você apenas os copie e cole.

Pré-requisitos

Para concluir este codelab, você precisa do seguinte:

2. Começar a configuração

Buscar o código

Colocamos todo o código necessário para este projeto em um repositório Git. Para começar, pegue o código e abra-o no seu ambiente de desenvolvimento favorito. Para este codelab, recomendamos o uso de um Raspberry Pi executando o Raspberry Pi OS (64 bits) com um computador. Isso facilita a conexão de um acelerador de corais.

Recomendado: usar 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). Nesse diretório, você encontrará subdiretórios chamados starter_code, cpu_inference_working, coral_inference_working e webnn_inference_working. Estes são os checkpoints das etapas deste codelab.

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

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

Os dispositivos Coral exigem que você instale a biblioteca Edge Runtime do Edge antes de usar. Faça a instalação seguindo as instruções da 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, você precisará compilá-lo a partir da fonte.

Execute este comando para adicionar o PPA do Coral do Google e instalar a biblioteca de ambiente de execução da Edge TPU.

# 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 nas versões x86-64 do MacOS e do Windows e podem ser instalados com install.sh ou install.bat. script no arquivo após o download.

Reiniciar o dispositivo

Após a instalação do Edge TPU Runtime, reinicie o dispositivo para ativar a nova regra Coral Udev adicionada pelo instalador.

Verificar se o dispositivo Coral foi detectado

Para verificar se o dispositivo Coral foi detectado e está funcionando, execute os testes de integração do pacote coral-tflite-delegate. Esse pacote está no diretório raiz do repositório. Para executar os testes de integração, conecte o acelerador Coral e execute estes comandos no diretório do pacote:

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

Você verá uma resposta como esta:

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,, conforme mencionado nos registros, porque você executará o modelo no TFLite.

Se a saída tiver Encountered unresolved custom op: edgetpu-custom-op, isso significa que o dispositivo Coral não foi detectado. Verifique se você instalou a biblioteca de tempo de execução da TPU e conectado o dispositivo Coral ao computador. Também é possível seguir o guia de primeiros passos do Coral 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.

Executar o código inicial

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

  1. Mova-o para o diretório starter_code no diretório tfjs-tflite-node-codelab.
  2. Execute 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 é aberto.

Qual é nosso ponto de partida?

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

Um app eletrônico básico com um feed ao vivo da câmera do dispositivo.

Explore o código inicial

Há muitos arquivos nesse código inicial, mas o único que você precisa editar é renderer.js. Ela controla o que será exibido na página, incluindo o feed de vídeo e os elementos HTML, e será onde você adicionará o modelo de machine learning ao app. Entre os outros arquivos está um arquivo index.html, mas basta carregar o renderer.js. Há também um arquivo main.js, que é o ponto de entrada para Electron. Ele controla o ciclo de vida do app, incluindo o que mostrar quando ele está aberto e o que fazer quando ele está fechado, mas não é necessário fazer mudanças.

Abrir o depurador

Talvez seja necessário depurar seu app ao seguir este codelab. Como esse app é baseado no Electron, ele tem o depurador do Chrome integrado. Na maioria das plataformas, você pode abri-lo com Ctrl + Shift + i. Clique na guia Console para ver registros e 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 imagem

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

Treinar o classificador

Um classificador de imagens usa imagens de entrada e atribui rótulos a elas. Neste codelab, você 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. No entanto, será necessário copiar os arquivos resultantes para o Pi.

Agora está tudo pronto para treinar um modelo. Se você não tem certeza do tipo de modelo a ser treinado, um modelo fácil é treinar um detector de pessoa, que apenas detecta se uma pessoa está no enquadramento.

  1. Abra a página de treinamento da Máquina que Aprende em uma nova guia.
  2. Selecione Image Project e escolha Standard image model.
  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. Quando você tiver coletado dados suficientes para cada classe (geralmente 50 amostras), pressione Treinar modelo.

Quando o treinamento do modelo for concluído, será exibida uma visualização da saída do modelo.

Um modelo é treinado com imagens de duas classes: "Pessoa" e "Sem pessoa". Uma demonstração do modelo treinado é executada em frames na câmera do dispositivo, e o próprio modelo pode ser transferido por download em vários formatos.

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

  1. Quando estiver tudo certo, clique em Exportar modelo. Você precisará fazer o download de duas versões diferentes do modelo.
  2. Exporte seu modelo como um modelo de ponto flutuante do TensorFlow Lite. Será feito o download de um arquivo chamado converted_tflite.zip. que é executado na CPU.
  3. Exporte seu modelo como um modelo do TensorFlow Lite EdgeTPU. Isso faz o download de um arquivo chamado converted_edgetpu.zip que é executado na TPU do Coral Edge.

4. Executar o modelo de CPU no seu app

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

Adicionar o arquivo de modelo ao app

Descompacte o arquivo de modelo converted_tflite.zip que você transferiu por download ao treinar o classificador. Há dois arquivos no arquivo. model_uquant.tflite é o modelo do TFLite salvo, incluindo o gráfico e os pesos do modelo. labels.txt contém os rótulos legíveis pelas classes que o modelo prevê. Coloque os dois arquivos no modeldirectory.

Instalar dependências

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

  • tfjs-tflite-node: o 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 o 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: importe o tfjs-tflite-node.

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

Carregar o modelo

Agora você pode carregar o modelo. tfjs-tflite-nodefornece oloadTFLiteModel para fazer isso. Ele pode carregar modelos de um caminho de arquivo, um ArrayBuffer ou um URL do TFHub. Para carregar o modelo e os pesos dele, adicione o seguinte à 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 requer três etapas. Primeiro, extraia e pré-processe um frame de entrada com a webcam. Em seguida, 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 de webcam

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

Para usá-lo, adicione este código de configuração a main():

Parte 1 do CODELAB: 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 ao run():

CODELAB parte 1: capture os frames da webcam aqui.

const image = await tensorCam.capture();

Também é necessário pré-processar cada frame para que ele seja compatível com o modelo. O modelo usado por este codelab tem a forma de entrada [1, 224, 224, 3]. Portanto, ele espera uma imagem RGB de 224 por 224 pixels.tensorCam.capture() oferece uma forma de [224, 224, 3], então você precisa 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 mudar o intervalo de [0, 255] para [0, ~2] e depois subtrair 1 para chegar ao intervalo desejado [-1, ~1]. Para fazer isso, adicione estas linhas a tf.tidy() na função run():

CODELAB parte 1: pré-processe os 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 após o uso. tf.tidy() faz isso automaticamente para o código contido no callback, mas não é compatível com funções assíncronas. Você precisará descartar manualmente o tensor de imagem criado anteriormente chamando o método dispose() dele.

Parte 1 do CODELAB: descarte frames de 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 que mostra a probabilidade prevista de cada rótulo. Multiplique essa probabilidade por 100 para chegar ao percentual de probabilidade 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 ajustar o tempo da previsão ao fazer chamadas para stats.begin e stats.end em torno das model.predict.

CODELAB parte 1: executar o modelo e exibir 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. Você verá as classificações do seu modelo.

O modelo de CPU TFLite é executado no app Electron. Ele classifica imagens da webcam e exibe valores de confiança para cada classe abaixo.

Desempenho

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

5. Executar o modelo de corais no 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 pode usar o checkpoint cpu_inference_working, se quiser começar do zero.

As etapas para executar o modelo de corais são quase idênticas às do modelo de CPU. A principal diferença é o formato do modelo. Como o Coral é compatível apenas com 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 um TPU da Coral. A TeachableMachine já realizou essa etapa, mas você pode aprender a fazer isso em outros modelos na documentação da Coral.

Adicionar o arquivo de modelo do Coral ao app

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

Instalar dependências

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

Os dispositivos de corais são acessados como delegados do TFLite. Para acessá-las a partir do 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:

Parte 2 do CODELAB: importe o delegado aqui.

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

Carregar o modelo

Agora você está pronto para carregar o modelo Coral. Isso é feito da mesma forma que o modelo da CPU. A diferença é que agora você transmite opções para a 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 é necessário carregar os rótulos porque eles são iguais aos do modelo de CPU.

Adicionar um botão para alternar entre a CPU e o Coral

Você adicionará o modelo de corais ao lado do modelo de CPU adicionado na última seção. A execução dos dois ao mesmo tempo dificulta a visualização das diferenças de desempenho. Portanto, um botão ativar alterna entre a execução do Coral e da CPU.

Adicione o botão com este código:

Parte 2 do CODELAB: 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 precisará executar a versão da CPU. Caso contrário, ele executará a versão da Coral (por enquanto, ela não fará nada). Envolva o código da execução do modelo de CPU em uma instrução if. O tensor expanded é omitido da instrução if porque o modelo Coral o usa.

Parte 2 do CODELAB: confira se o delegado será usado aqui.

// 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.

Parte 2 do CODELAB: faça a previsão do Coral 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. Ele exibirá classificações do acelerador Coral.

Os modelos de CPU e Coral são executados no app, um de cada vez, e um botão alterna entre eles. O modelo da CPU tem cerca de 20 QPS e o modelo de corais tem cerca de 45.

Para alternar entre a inferência de coral e CPU, pressione o botão. Você pode notar que as classificações de confiança do modelo Coral são menos precisas do que as do modelo de CPU. Geralmente, elas terminam com uma casa decimal. Essa perda de precisão é uma compensação da execução de um modelo quantizado na Coral. Isso não costuma ser importante na prática, mas é algo a se considerar.

Observação sobre desempenho

O frame rate inclui o pré-processamento e o pós-processamento. Por isso, ele não representa a capacidade do hardware da Coral. Você pode ter uma ideia melhor do desempenho clicando no medidor de FPS até ele mostrar 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, em seguida, para o dispositivo Coral. Portanto, essa não é uma medição perfeita. Para ver comparativos de desempenho mais precisos escritos em C++, consulte a página de comparativo de mercado da EdgeTPU (em inglês).

Além disso, o vídeo foi gravado em um laptop, e não em um Raspberry Pi. Por isso, talvez você veja um FPS diferente.

Como acelerar o pré-processamento do Coral

Em alguns casos, é possível acelerar o pré-processamento trocando os back-ends do TFJS. O back-end padrão é a WebGL, que é boa para operações grandes e com carregamento em paralelo, mas o app não faz muito disso na fase de pré-processamento. A única operação usada é a expandDims, que não é paralela. É possível alternar para o back-end da CPU para evitar a latência extra de mover tensores para e da GPU adicionando essa linha após as importações na parte superior do arquivo.

tf.setBackend(‘cpu');

Isso também afeta o pré-processamento do modelo de CPU TFLite, que é colocado em paralelo para que o modelo seja executado muito mais lentamente com essa mudança.

6. Acelerar o modelo de CPU com o WebNN

Se você não tiver um acelerador de corais ou quiser apenas testar outra maneira de acelerar o modelo, use o delegado WebLite TFLite (em inglês). Este delegado usa hardware de machine learning integrado a processadores Intel para acelerar a inferência de modelos com o kit de ferramentas OpenVINO (em inglês). Consequentemente, ela tem requisitos adicionais que não foram abordados na seção de configuração deste codelab. Você precisará instalar o kit de ferramentas do OpenVINO. Verifique sua configuração em relação às plataformas de sistema de destino compatíveis antes de continuar, mas o delegado WebNN ainda não é compatível com o macOS.

Instalar o kit de ferramentas do OpenVINO

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

Verificar se o delegado da WebNN está funcionando

Para verificar se o delegado da WebNN está funcionando corretamente, execute os testes de integração do 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

Você verá uma resposta como esta:

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.

Se você vir uma saída como esta, um erro de configuração será exibido:

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.

Isso provavelmente significa que você não definiu as variáveis de ambiente do OpenVINO. Por enquanto, você pode configurá-los executando o comando setupvars.sh (Linux) ou setupvars.bat (Windows), mas é recomendável defini-los permanentemente seguindo as instruções do Linux ou Instruções para Windows ( solução permanente). Se você usa o Windows, a

setupvars.bat

O comando não é compatível com o bash do Git. Portanto, execute-o com outros comandos deste codelab usando o 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 na seção "Executar o modelo de CPU no seu app". Use o código que você criou nesta etapa. Se você já tiver concluído a seção "Coral", use o checkpoint cpu_inference_working para começar com uma barreira limpa.

A parte Node.js do delegado da WebNN é distribuída no 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:

Parte 2 do CODELAB: importe o delegado aqui.

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

O delegado da WebNN é compatível com a execução na CPU ou na GPU; O WebNNDevice permite que você escolha qual usar.

Carregar o modelo

Agora você está pronto para carregar o modelo com o delegado WebNN ativado. Para o Coral, era necessário carregar um arquivo de modelo diferente, mas o WebNN é compatível com o mesmo formato de modelo do 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 o modelo é o mesmo.

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

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

Adicione o botão com este código (ele não mudará os modelos ainda):

Parte 2 do CODELAB: 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 do WebNN na próxima seção.

Adicionar um menu suspenso para alternar entre dispositivos WebNN

O WebNN é compatível com a execução na CPU e na GPU. Portanto, adicione um menu suspenso para alternar entre eles. 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, verá uma lista suspensa com as opções "Default", "GPU" e "CPU". Escolher uma delas não fará nada agora, porque o menu suspenso ainda não está conectado. O app mostra um menu suspenso em que o dispositivo WebNN pode ser selecionado em &quot;Padrão&quot;, &quot;GPU&quot; ou &quot;CPU&quot;.

Fazer o menu suspenso mudar o dispositivo

Para conectar o menu suspenso para que ele altere qual dispositivo WebNN é usado, adicione um listener ao evento change do elemento do seletor 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 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 alteração, o menu suspenso cria um novo modelo com as configurações corretas toda vez que for alterado. Agora, é hora de conectar o modelo WebNN e usá-lo para inferência.

Executar o modelo WebNN

O modelo WebNN está pronto para ser usado, mas o botão para alternar entre a CPU WebNN e a TfLite ainda não muda o modelo. Para alternar o modelo, primeiro você precisa renomear a variável model ao carregar o modelo de CPU TfLite na primeira seção do codelab.

Mude a seguinte linha...

const model = await loadTFLiteModel(modelPath);

para que ele corresponda a essa linha.

const cpuModel = await loadTFLiteModel(modelPath);

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

Parte 2 do CODELAB: confira se o delegado será usado aqui.

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

Agora, quando você executa o app, o botão alterna entre a CPU TfLite e a WebNN. O modelo de CPU TFLite e os modelos de CPU e GPU WebNN são executados no app. Quando um dos modelos WebNN está ativo, um menu suspenso alterna entre eles. O modelo de CPU tem aproximadamente 15 FPS e o de CPU WebNN tem aproximadamente 40.

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

Observação sobre desempenho

O frame rate que você vê inclui o pré-processamento e o pós-processamento. Por isso, ele não representa a capacidade do WebNN. Você pode ter uma ideia melhor do desempenho clicando no medidor de FPS até ele mostrar 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, portanto, essa não é uma medição perfeita.

7. Parabéns

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

Faça isso e teste com várias imagens. Também é possível treinar um novo modelo no TeachableMachine para classificar algo completamente diferente.

Resumo

Neste codelab, você aprendeu:

  • Como instalar e configurar o pacote npm tfjs-tflite-node para executar modelos TFLite em Node.js
  • Como instalar a biblioteca de tempo de execução da 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 modelos com o WebNN.

Qual é a próxima etapa?

Agora que você já tem uma base de trabalho para começar, quais ideias criativas você pode adotar para ampliar esse executor de modelos de machine learning para um caso de uso real em que você possa estar trabalhando? É possível revolucionar o setor em que você trabalha com inferência rápida e acessível ou modificar uma torradeira para que ela pare de torrar quando estiver no ar. As possibilidades são infinitas.

Para saber mais sobre como a TeachableMachine treinou o modelo que você usou, confira o 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, acesse coral.ai/models. Você também pode encontrar versões da CPU desses modelos e de muitos outros no TensorFlow Hub.

Compartilhe o que você sabe conosco

É fácil estender o que você fez hoje para outros casos de uso de criativo. Além disso, recomendamos que você pense fora da caixa e continue a invadir.

Lembre-se de nos marcar nas mídias sociais usando a hashtag #MadeWithTFJS para que seu projeto tenha a chance de ser destacado no nosso blog do TensorFlow ou até mesmo em eventos futuros. Adoraríamos ver o que você fará.

Sites para conferir