Esta página foi traduzida pela API Cloud Translation.

Reconhecimento de fala com IA usando o TensorFlow Lite para microcontroladores e SparkFun Edge

1. Introdução

O que você vai criar

Neste codelab, vamos aprender a usar o TensorFlow Lite para microcontroladores para executar um modelo de aprendizado profundo na Placa de desenvolvimento do SparkFun Edge. Trabalharemos com o modelo integrado de detecção de fala do board, que usa uma rede neural convolucional para detectar as palavras "sim". e "não" sendo falada pelos dois microfones do quadro.

Machine learning em microcontroladores

O machine learning pode ser usado para criar ferramentas inteligentes que tornam como o Google Assistente. No entanto, essas experiências costumam exigir muita computação ou recursos, como um servidor de nuvem potente ou um desktop. No entanto, agora é possível realizar inferências de machine learning em hardwares minúsculos e de baixa potência, como microcontroladores.

Microcontroladores são extremamente comuns, baratos, requerem muito pouca energia e são muito confiáveis. Eles são parte de todos os tipos de dispositivos domésticos: eletrodomésticos, carros e brinquedos. Na verdade, cerca de 30 bilhões de dispositivos com microcontroladores são produzidos todos os anos.

Ao levar o aprendizado de máquina para microcontroladores minúsculos, podemos aumentar a inteligência de bilhões de dispositivos que usamos em nossas vidas, sem depender de hardware caro ou conexões de Internet confiáveis. Imagine eletrodomésticos inteligentes que se adaptam à sua rotina diária, sensores industriais inteligentes que entendem a diferença entre problemas e operação normal e brinquedos mágicos que podem ajudar as crianças a aprender de forma divertida e divertida.

TensorFlow Lite para microcontroladores (software)

O TensorFlow é o framework de machine learning de código aberto do Google para treinamento e execução de modelos. O TensorFlow Lite é um framework de software, uma versão otimizada do TensorFlow, destinada à execução de modelos do TensorFlow em dispositivos pequenos e relativamente de baixa potência, como smartphones.

O TensorFlow Lite para microcontroladores é um framework de software, uma versão otimizada do TensorFlow, destinada a executar modelos do TensorFlow em hardware pequeno e de baixa potência, como microcontroladores. Ele segue as restrições exigidas nesses ambientes incorporados, ou seja, tem um tamanho binário pequeno, não precisa de suporte a sistemas operacionais, bibliotecas C ou C++ padrão, alocação de memória dinâmica etc.

SparkFun Edge (hardware)

O SparkFun Edge é uma plataforma baseada em microcontroladores: um computador pequeno em uma única placa de circuito. Ele tem processador, memória e hardware de E/S que permitem enviar e receber sinais digitais para outros dispositivos. Ele tem quatro LEDs controlados por software nas suas cores favoritas do Google.

Ao contrário de um computador, um microcontrolador não executa um sistema operacional. Em vez disso, os programas que você escreve são executados diretamente no hardware. Você escreve o código em um computador e faz o download dele para o microcontrolador usando um dispositivo chamado programador.

Microcontroladores não são computadores poderosos. Elas têm processadores pequenos e pouca memória. No entanto, como eles foram projetados para ser o mais simples possível, um microcontrolador pode usar pouquíssima energia. Dependendo do que seu programa faz, o SparkFun Edge pode ser executado por semanas em uma única bateria do tipo moeda.

O que você vai aprender

Compile o programa de amostra para o SparkFun Edge no seu computador
Implantar o programa no dispositivo
Fazer alterações no programa e implantá-lo novamente

O que é necessário

Você precisará do seguinte hardware:

Computador Linux ou MacOS
Placa SparkFun Edge
Programador SparkFun USB-C Serial Basic
Cabo USB-C para USB-A (se você estiver em um computador USB-C, use o cabo USB-C para USB-C)
(Opcional) Bateria de lítio tipo moeda de 20 mm 3 V (CR2032) para executar inferência sem um programador e um cabo

Você precisará dos seguintes softwares:

Git (verifique se ele está instalado executando git na linha de comando)
Python 3 (verifique se ele está instalado executando python3 ou python --version na linha de comando)
Pip para Python 3 ( resposta útil do StackOverflow)
Faça a versão 4.2.1 ou mais recente. Para verificar se ela está instalada, execute make --version na linha de comando.
Drivers da SparkFun Serial Basic

2. Configurar o hardware

O microcontrolador SparkFun Edge vem com um binário pré-instalado que pode executar o modelo de fala. Antes de substituirmos pela nossa própria versão, vamos executar o modelo.

Ligue a placa:

Inserindo uma bateria de célula do tipo moeda no conector da bateria, na parte de trás da placa (com o lado "+" da bateria voltado para cima. Se a placa veio com uma bateria já inserida, puxe a aba de plástico e empurre a bateria para garantir que ela esteja totalmente inserida.

Se você não tiver uma bateria do tipo moeda, use o dispositivo de programação SparkFun USB-C Serial Basic para energizar a placa. Para conectar esse dispositivo à placa, siga estas etapas:

Localize o cabeçalho com seis pinos na lateral do SparkFun Edge.
Conecte o SparkFun USB-C Serial Basic a esses pinos, certificando-se de que os pinos com a etiqueta "BLK" estejam e "GRN" de cada dispositivo estejam alinhados corretamente.
Conecte um cabo USB-C entre o SparkFun USB-C Serial Basic e o computador.

Depois de carregar a placa, inserindo a bateria ou conectando o programador USB, a placa vai despertar e começar a ouvir com os microfones. A luz azul vai começar a piscar.

O modelo de machine learning no quadro é treinado para reconhecer as palavras "sim" e "não" e para detectar a presença e ausência de fala. Ela comunica os resultados acendendo LEDs coloridos. A tabela a seguir mostra o significado de cada cor de LED:

Resultado da detecção	Cor do LED
"Sim"	Amarelo
"Não"	Vermelho
Fala desconhecida	Verde
Nenhuma fala detectada	Nenhum LED aceso

Faça um teste

Levante o tabuleiro na boca e diga "sim" algumas vezes. O LED amarelo pisca. Se nada acontecer quando você disser "sim", tente fazer o seguinte:

Segure o tabuleiro por volta de 25 cm da sua boca
Evite ruídos de fundo em excesso
Repetir "sim" várias vezes em sequência (tente dizer "sim, sim, sim")

3. Configurar o software

Agora vamos fazer o download, instalar e executar o modelo de fala no microcontrolador por conta própria. Para isso, primeiro fazemos o download do código-fonte deste programa e das dependências necessárias para criá-lo. O programa é escrito em C++, que precisa ser compilado em um binário antes do download na placa. Um binário é um arquivo que contém o programa em um formato que pode ser executado diretamente pelo hardware do SparkFun Edge.

As instruções a seguir foram criadas para Linux ou MacOS.

Faça o download do repositório do TensorFlow

O código está disponível no repositório do TensorFlow no GitHub, no seguinte local:

https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/micro

Abra um terminal no computador, mude para um diretório onde você geralmente armazena projetos de programação, faça o download do repositório do TensorFlow e insira o diretório criado, conforme mostrado abaixo:

cd ~  # change into your home (or any other) directory
git clone --depth 1 https://github.com/tensorflow/tensorflow.git
cd tensorflow

Fazer o download das dependências do Python

Usaremos o Python 3 para preparar nosso binário e atualizá-lo no dispositivo. Os scripts Python dependem da disponibilidade de determinadas bibliotecas. Execute o comando a seguir para instalar essas dependências:

pip3 install pycrypto pyserial --user

4. Criar e preparar o binário

Vamos criar o binário e executar comandos que o preparam para download no dispositivo.

Criar o binário

Para fazer o download de todas as dependências necessárias e criar o binário, execute o seguinte comando:

make -f tensorflow/lite/micro/tools/make/Makefile TARGET=sparkfun_edge micro_speech_bin

Se o build funcionar, a linha final da saída será semelhante a esta:

arm-none-eabi-objcopy tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin -O binary

Para confirmar se o binário foi criado, execute o seguinte comando:

test -f \
tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin && \
 echo "Binary was successfully created" || echo "Binary is missing"

Você verá Binary was successfully created exibido no console. Se Binary is missing aparecer, isso significa que houve um problema com o processo de build que exigirá depuração.

Preparar o binário

O binário precisa ser assinado com chaves criptográficas para ser implantado no dispositivo. Agora vamos executar alguns comandos que assinarão nosso binário para que ele possa ser baixado no SparkFun Edge.

Digite o comando abaixo para configurar algumas chaves de criptografia fictícias que podem ser usadas para desenvolvimento:

cp tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info0.py tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info.py

Agora, execute o seguinte comando para criar um binário assinado:

python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_image_blob.py \
--bin tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin \
--load-address 0xC000 \
--magic-num 0xCB \
-o main_nonsecure_ota \
--version 0x0

Isso criará o arquivo main_nonsecure_ota.bin. Agora, vamos executar outro comando para criar uma versão final do arquivo que pode ser usada para atualizar o dispositivo com o script do carregador de inicialização que vamos usar na próxima etapa:

python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_wireupdate_blob.py \
--load-address 0x20000 \
--bin main_nonsecure_ota.bin \
-i 6 \
-o main_nonsecure_wire \
--options 0x1

Agora você terá um arquivo com o nome main_nonsecure_wire.bin no diretório em que executou os comandos. Este é o arquivo que vamos atualizar no dispositivo.

5. Preparar-se para atualizar o binário

O que é piscando?

O SparkFun Edge armazena o programa que está em execução no momento em seus 512 kilobytes de memória flash. Se quisermos que a placa execute um novo programa, precisamos enviá-lo para a placa, que o armazenará na memória flash, substituindo qualquer programa salvo anteriormente.

Esse processo é chamado de "atualização" e será usado para enviar nosso programa para a diretoria.

Conectar o programador à placa

Para fazer o download de novos programas na placa, usaremos o programador em série SparkFun USB-C Serial Basic. Esse dispositivo permite que seu computador se comunique com o microcontrolador via USB.

Para conectar esse dispositivo à placa, siga estas etapas:

Localize o cabeçalho com seis pinos na lateral do SparkFun Edge.
Conecte o SparkFun USB-C Serial Basic a esses pinos, certificando-se de que os pinos com a etiqueta "BLK" estejam e "GRN" de cada dispositivo estejam alinhados corretamente.

Conectar o programador ao computador

Vamos conectar a placa ao seu computador via USB. Para programar a placa, precisamos saber o nome que seu computador dá ao dispositivo. A melhor maneira de fazer isso é listar todos os dispositivos do computador antes e depois de conectá-lo e verificar qual dispositivo é novo.

Antes de conectar o dispositivo via USB, execute o seguinte comando:

If you are using Linux: ls /dev/tty*
If you are using MacOS: ls /dev/cu*

Isso vai gerar uma lista de dispositivos conectados parecida com esta:

/dev/cu.Bluetooth-Incoming-Port
/dev/cu.MALS
/dev/cu.SOC

Agora, conecte o programador à porta USB do computador. Digite o seguinte comando novamente:

If you are using Linux: ls /dev/tty*
If you are using MacOS: ls /dev/cu*

Você verá um item extra na saída, como no exemplo abaixo. Talvez seu novo item tenha outro nome. Esse novo item é o nome do dispositivo.

/dev/cu.Bluetooth-Incoming-Port
/dev/cu.MALS
/dev/cu.SOC
/dev/cu.wchusbserial-1450

Primeiro, criaremos uma variável de ambiente para identificar o nome do dispositivo:

export DEVICENAME=put your device name here

Em seguida, criaremos uma variável de ambiente para especificar a taxa de Baud, que é a velocidade com que os dados serão enviados ao dispositivo:

export BAUD_RATE=921600

6. Atualizar o binário

Executar o script para atualizar o quadro

Para atualizar a placa, temos que colocá-la em um "carregador de inicialização" especial que o prepara para receber o novo binário. Vamos executar um script para enviar o binário à placa.

Vamos conhecer os seguintes botões no painel:

Siga estas etapas para redefinir e atualizar a placa:

Confira se a placa está conectada ao programador e se toda a configuração está conectada ao computador via USB.
Comece segurando o botão marcado como 14 no quadro. Mantenha-o pressionado até a Etapa 6.
Ainda segurando o botão marcado como 14, para redefinir a placa para o estado do carregador de inicialização, clique no botão marcado como RST para redefinir a placa.
Ainda segurando o botão marcado como 14, cole o comando a seguir no terminal e pressione Enter para executá-lo. Para facilitar, cole o comando no terminal antes de começar a pressionar o botão, mas não pressione Enter até chegar a esta etapa.

python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/uart_wired_update.py -b ${BAUD_RATE} ${DEVICENAME} -r 1 -f main_nonsecure_wire.bin -i 6

Ainda segurando o botão marcado como 14, você verá algo parecido com o seguinte na tela:

Connecting with Corvette over serial port /dev/cu.usbserial-1440...
Sending Hello.
Received response for Hello
Received Status
length =  0x58
version =  0x3
Max Storage =  0x4ffa0
Status =  0x2
State =  0x7
AMInfo =
0x1
0xff2da3ff
0x55fff
0x1
0x49f40003
0xffffffff
[...lots more 0xffffffff...]
Sending OTA Descriptor =  0xfe000
Sending Update Command.
number of updates needed =  1
Sending block of size  0x158b0  from  0x0  to  0x158b0
Sending Data Packet of length  8180
Sending Data Packet of length  8180
[...lots more Sending Data Packet of length  8180...]

Pare de pressionar o botão marcado com 14 no quadro depois de ver Sending Data Packet of length 8180 (mas você pode continuar segurando-o). O programa vai continuar mostrando linhas no terminal. Em algum momento, ele vai ficar parecido com este:

[...lots more Sending Data Packet of length  8180...]
Sending Data Packet of length  8180
Sending Data Packet of length  6440
Sending Reset Command.
Done.

Se Done aparecer, isso indica uma atualização bem-sucedida. Se a saída do programa terminar com um erro, verifique se Sending Reset Command foi mostrado. Nesse caso, a atualização provavelmente foi bem-sucedida, apesar do erro.

Em uma máquina Linux, você pode encontrar uma NoResponse Error. Isso ocorre porque o driver serial ch34x foi instalado junto com o driver serial atual, o que pode ser resolvido da seguinte maneira:

Etapa 1: reinstale a versão correta da biblioteca ch34x. Verifique se o dispositivo está desconectado do computador durante a instalação.

git clone https://github.com/juliagoda/CH341SER.git
cd CH341SER/
make
sudo insmod ch34x.ko
sudo rmmod ch341

Etapa 2: conecte o USB da placa e execute o seguinte:

dmesg | grep "ch34x"

Você verá uma mensagem como esta:

[ 1299.444724]  ch34x_attach+0x1af/0x280 [ch34x]
[ 1299.445386] usb 2-13.1: ch34x converter now attached to ttyUSB0

Se o driver usado não for "ch34x", (por exemplo: ch341), tente desativar o outro driver executando:

rmmod <non-ch34x driver name>

Desconecte e reconecte o dispositivo e verifique se o driver usado é "ch34x".

7. Demonstração

Teste o programa

Depois que o tabuleiro tiver piscado, aperte o botão marcado

RST para reiniciar o quadro e iniciar o programa. Se o LED azul começar a piscar, a ação foi concluída. Caso contrário, role para baixo até a seção E se não funcionar? abaixo.

Resultado da detecção	Cor do LED
"Sim"	Amarelo
"Não"	Vermelho
Fala desconhecida	Verde
Nenhuma fala detectada	Nenhum LED aceso

Faça um teste

Levante o tabuleiro na boca e diga "sim" algumas vezes. O LED amarelo pisca. Se nada acontecer quando você disser "sim", tente fazer o seguinte:

Segure o tabuleiro por volta de 25 cm da sua boca
Evite ruídos de fundo em excesso
Repetir "sim" várias vezes em sequência (tente dizer "sim, sim, sim")

E se não funcionar?

Aqui estão alguns possíveis problemas e como depurá-los:

Problema: depois de piscar, nenhum dos LEDs está acendendo.

Solução:tente pressionar o botão RST ou desconecte e reconecte a placa do programador. Se nada disso funcionar, tente atualizar o painel novamente.

Problema: o LED azul está acendendo, mas está muito escuro.

Solução:substitua a bateria porque ela está acabando. Como alternativa, a placa pode ser alimentada por computador, usando o programador e o cabo.

8. Ler a saída de depuração (opcional)

Consulte esta seção se você enfrentar problemas e precisar depurar o código em detalhes. Para entender o que está acontecendo em um microcontrolador quando seu código é executado, você pode imprimir informações de depuração pela conexão serial da placa. Você usa seu computador para se conectar à placa e exibir os dados que ela está enviando.

Abrir uma conexão serial

Por padrão, o exemplo de código do SparkFun Edge registra todos os comandos falados e a confiança deles. Para conferir a saída da placa, execute o seguinte comando:

screen ${DEVICENAME} 115200

Inicialmente, você poderá ver uma saída semelhante a esta: (isso só aparecerá se a placa for redefinida após a conexão. Caso contrário, você pode começar a ver informações de depuração)

Apollo3 Burst Mode is Available

                               Apollo3 operating in Burst Mode (96MHz)

Diga "sim" em alguns comandos ou "não". Você vai encontrar as informações de depuração de impressão da placa para cada comando:

 Heard yes (202) @65536ms

No registro acima, yes se refere ao comando. O número 202 se refere ao nível de confiança de que o comando foi ouvido (sendo 200 o mínimo). Por fim, 65536ms refere-se ao tempo decorrido desde a última redefinição do microcontrolador.

Para interromper a visualização da saída de depuração, pressione Ctrl+A, imediatamente seguido pela chave K e pressione a tecla Y.

Gravar registros de depuração

Você pode ver o código que registra essas informações no arquivo command_responder.cc com o qual você estava trabalhando:

tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc

Para registrar dados, chame o método error_reporter->Report(). Ela oferece suporte aos tokens padrão printf para interpolação de strings, que podem ser usados para incluir informações importantes nos registros:

error_reporter->Report("Heard %s (%d) @%dms", found_command, score, current_time);

Esse método será útil quando você estiver fazendo suas próprias alterações no código na próxima seção.

9. Estender o código (opcional)

Agora que você sabe como criar e atualizar o SparkFun Edge, comece a testar o código e a implementá-lo no dispositivo para ver os resultados.

Ler o código

Um bom lugar para começar a ler o código é o arquivo a seguir, command_responder.cc..

tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc

Confira o arquivo no GitHub aqui (link em inglês).

O método neste arquivo, RespondToCommand, é chamado quando um comando de voz é detectado. O código atual acende um LED diferente, dependendo se "yes", "no" ou um comando desconhecido foi ouvido. O snippet a seguir mostra como isso funciona:

if (found_command[0] == 'y') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
}
if (found_command[0] == 'n') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
}
if (found_command[0] == 'u') {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
}

O argumento found_command contém o nome do comando que foi detectado. Ao verificar o primeiro caractere, esse conjunto de instruções if determina qual LED vai acender.

O método RespondToCommand é chamado com vários argumentos:

void RespondToCommand(tflite::ErrorReporter* error_reporter,
    int32_t current_time, const char* found_command,
    uint8_t score, bool is_new_command) {

O error_reporter é usado para registrar informações de depuração. Falaremos sobre isso mais adiante.
current_time representa o horário em que o comando foi detectado.
found_command informa qual comando foi detectado.
A score indica o nível de confiança na detecção de um comando.
O is_new_command nos informa se esta é a primeira vez que ouve o comando.

O score é um número inteiro de 0 a 255 que representa a probabilidade de um comando ter sido detectado. O exemplo de código só considera um comando válido se a pontuação for maior que 200. Com base em nossos testes, a maioria dos comandos válidos se enquadra no intervalo de 200 a 210.

Modificar o código

A placa SparkFun Edge tem quatro LEDs. No momento, a luz de LED azul pisca para indicar que o reconhecimento está ocorrendo. É possível conferir isso no arquivo command_responder.cc:

static int count = 0;

// Toggle the blue LED every time an inference is performed.
++count;
if (count & 1) {
  am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
} else {
  am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
}

Como temos um banco de quatro LEDs, vamos modificar o programa para usá-los como um indicador visual do score de um determinado comando. Uma pontuação baixa justifica um único LED aceso e uma pontuação mais alta resulta em várias luzes.

Para saber se o programa está em execução, o LED vermelho pisca continuamente em vez de azul. Os LEDs azuis, verdes e amarelos adjacentes serão usados para mostrar a intensidade das score mais recentes. Para simplificar, só vamos acender esses LEDs se a palavra "yes" é falado. Se outra palavra for detectada, os LEDs apagarão.

Para fazer essa mudança, substitua todo o código no seu arquivo command_responder.cc pelo seguinte snippet:

#include "tensorflow/lite/micro/examples/micro_speech/command_responder.h"

#include "am_bsp.h"

// This implementation will light up the LEDs on the board in response to different commands.
void RespondToCommand(tflite::ErrorReporter* error_reporter,
                      int32_t current_time, const char* found_command,
                      uint8_t score, bool is_new_command) {
  static bool is_initialized = false;
  if (!is_initialized) {
    // Setup LEDs as outputs
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_RED, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_BLUE, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_GREEN, g_AM_HAL_GPIO_OUTPUT_12);
    am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_YELLOW, g_AM_HAL_GPIO_OUTPUT_12);
    // Ensure all pins are cleared
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
    is_initialized = true;
  }
  static int count = 0;

   // Toggle the red LED every time an inference is performed.
   ++count;
   if (count & 1) {
     am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
   } else {
     am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
   }

  if (is_new_command) {
    // Clear the last three LEDs
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
    am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
    error_reporter->Report("Heard %s (%d) @%dms", found_command, score,
                           current_time);
    // Only indicate a 'yes'
    if (found_command[0] == 'y') {
      // Always light the blue LED
      am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
      // Light the other LEDs depending on score
      if (score >= 205) {
        am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
      }
      if(score >= 210) {
        am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
      }
    }
  }
}

Se um novo comando for detectado, is_new_command será verdadeiro. Vamos apagar os LEDs azul, verde e amarelo e acendê-los novamente, dependendo dos valores de found_command e score.

Recriar e atualizar

Depois de fazer mudanças no código, teste-o executando todas as etapas em Criar e preparar o binário.

10. Próximas etapas

Parabéns! Você criou seu primeiro detector de fala em um microcontrolador.

Esperamos que você tenha gostado desta breve introdução ao desenvolvimento com o TensorFlow Lite para microcontroladores. A ideia do aprendizado profundo em microcontroladores é nova e empolgante, e recomendamos que você saia e experimente.

Documentos de referência

Treine seu próprio modelo para entender comandos diferentes, agora que você tem experiência em trabalhar com o programa básico. Observação: o treinamento levará algumas horas.
Saiba mais sobre o TensorFlow Lite para microcontroladores ( site, GitHub).
Teste outros exemplos (em inglês) e execute-os no SparkFun Edge, se ele for compatível.
Consulte o livro da O'Reilly: TinyML: Machine Learning with TensorFlow on Arduino and Ultra-Low Power Micro-Controllers (em inglês), que apresenta o machine learning em dispositivos pequenos e mostra vários projetos divertidos. Este codelab é baseado nos capítulos 7 e 8 do livro.

Obrigado e divirta-se criando!