1. Antes de começar
O TensorFlow é um framework de machine learning multiuso. Ele pode ser usado para treinar modelos enormes em clusters na nuvem ou executar modelos localmente em um sistema incorporado, como seu smartphone.
Este codelab usa o TensorFlow Lite para executar um modelo de classificação de áudio em um dispositivo Android.
O que você aprenderá
- Como encontrar um modelo de machine learning pré-treinado pronto para ser usado.
- Como fazer a classificação de áudio em tempo real.
- Como usar a Biblioteca de Suporte do TensorFlow Lite para pré-processar a entrada de modelo e pós-processar a saída do modelo.
- Como usar a Biblioteca de tarefas de áudio para fazer todo o trabalho relacionado ao áudio.
O que você criará
Um app reconhecedor de áudio simples que executa um modelo de reconhecimento de áudio do TensorFlow Lite para identificar áudios do microfone em tempo real
Pré-requisitos
- Uma versão recente do Android Studio (v4.1.2 ou mais recente)
- Dispositivo físico Android com a versão 23 da API (Android 6.0)
- Código de amostra
- Conhecimento básico de desenvolvimento Android no Kotlin.
2. Como obter o código de amostra
Fazer o download do código
Clique no link abaixo para fazer o download de todo o código para este codelab:
Descompacte o arquivo ZIP transferido por download. Isso descompactará uma pasta raiz (odml-pathways) com todos os recursos necessários. Neste codelab, você só precisará das origens no subdiretório audio_classification/codelab1/android.
Observação:se você preferir clonar o repositório:
git clone https://github.com/googlecodelabs/odml-pathways.git
O subdiretório android no repositório audio_classification/codelab1/android contém dois diretórios:
starter: o código inicial que você usará como base para este codelab.- final: o código concluído do app de exemplo finalizado.
Importar o app inicial
Vamos começar importando o app inicial para o Android Studio.
- Abra o Android Studio e selecione Import Project (Gradle, Eclipse ADT, etc.)
- Abra a pasta
starter(audio_classification/codelab1/android/starter) no código-fonte que você salvou antes.
Para garantir que todas as dependências estejam disponíveis para seu app, sincronize o projeto com arquivos do Gradle quando o processo de importação for concluído.
- Selecione Sync Project with Gradle Files (
) na barra de ferramentas do Android Studio.
Executar o app inicial
Agora que você importou o projeto para o Android Studio, está pronto para executar o app pela primeira vez.
Conecte o dispositivo Android via USB ao computador e clique em Run ( 
) na barra de ferramentas do Android Studio.
3. Encontrar um modelo pré-treinado
Para fazer a classificação de áudio, você precisará de um modelo. Comece com um modelo pré-treinado para que você não precise treinar um.
Para encontrar modelos pré-treinados, use o TensorFlow Hub ( www.tfhub.dev).
Os modelos são categorizados por domínios. O que você precisa no momento é dos Domínios com problemas de áudio.
Para o app, você fará a classificação de eventos com o modelo YAMNet.
O YAMNet é um classificador de eventos de áudio que usa a forma de onda de áudio como entrada e faz previsões independentes para cada um dos 521 eventos de áudio.
O modelo yamnet/classification já foi convertido no TensorFlow Lite e tem metadados específicos que permitem que a Biblioteca de tarefas do TFLite para áudio facilite o uso do modelo em dispositivos móveis.
Escolha a guia correta: TFLite (yamnet/classification/tflite) e clique em Fazer o download. Também é possível ver os metadados do modelo na parte inferior.
Este arquivo de modelo (lite-model_yamnet_classification_tflite_1.tflite) será usado na próxima etapa.
4. Importar o novo modelo para o app base
A primeira etapa é mover o modelo transferido da etapa anterior para a pasta de recursos no seu app.
No Android Studio, no explorador de projetos, clique com o botão direito do mouse na pasta assets.
Você verá um pop-up com uma lista de opções. Uma delas será abrir a pasta no seu sistema de arquivos. Em um Mac, ele será Reveal in Finder ou, no Windows, Open in Explorer e, no Ubuntu, Show in Files. Encontre e selecione o sistema adequado para seu sistema operacional.
Em seguida, copie o modelo salvo.
Depois de fazer isso, volte ao Android Studio, e você verá seu arquivo na pasta assets.
5. Carregar o novo modelo no app base
Agora você seguirá algumas das TODOs e ativará a classificação de áudio com o modelo que acabou de adicionar ao projeto na etapa anterior.
Para encontrar os TODOs com facilidade, no Android Studio, acesse o menu: View > Tool Windows > TODO. Uma janela será aberta com a lista, e você poderá clicar nela para ir direto ao código.
No arquivo build.gradle (a versão do módulo), você encontrará a primeira tarefa.
TODO 1 é adicionar as dependências do Android:
implementation 'org.tensorflow:tensorflow-lite-task-audio:0.2.0'
Todas as outras mudanças no código serão feitas no MainActivity
O TODO 2.1 cria a variável com o nome do modelo a ser carregado nas próximas etapas.
var modelPath = "lite-model_yamnet_classification_tflite_1.tflite"
TODO 2.2, você definirá um limite mínimo para aceitar uma previsão do modelo. Essa variável será usada mais tarde.
var probabilityThreshold: Float = 0.3f
TODO 2.3 é onde você carregará o modelo da pasta de recursos. A classe AudioClassifier definida na Biblioteca de tarefas de áudio está preparada para carregar o modelo e fornecer todos os métodos necessários para executar a inferência, além de ajudar a criar um gravador de áudio.
val classifier = AudioClassifier.createFromFile(this, modelPath)
6. Capturar áudio
A API Audio Tasks tem alguns métodos auxiliares para ajudar a criar um gravador de áudio com a configuração adequada esperada pelo modelo (por exemplo: taxa de amostragem, taxa de bits, número de canais). Com isso, você não precisa encontrá-lo manualmente e também criar objetos de configuração.
TODO 3.1:crie a variável do tensor que armazenará a gravação para inferência e crie a especificação do formato do gravador.
val tensor = classifier.createInputTensorAudio()
TODO 3.2:mostra as especificações do gravador de áudio que foram definidas pelos metadados do modelo na etapa anterior.
val format = classifier.requiredTensorAudioFormat
val recorderSpecs = "Number Of Channels: ${format.channels}\n" +
"Sample Rate: ${format.sampleRate}"
recorderSpecsTextView.text = recorderSpecs
TODO 3.3: crie o gravador de áudio e comece a gravar.
val record = classifier.createAudioRecord()
record.startRecording()
No momento, o app está ouvindo no microfone do smartphone, mas ainda não está fazendo nenhuma inferência. Você resolverá isso na próxima etapa.
7. Adicionar a inferência ao modelo
Nesta etapa, você adicionará o código de inferência ao app e o exibirá na tela. O código já tem uma linha de execução do timer que é executada a cada meio segundo e é onde a inferência será executada.
Os parâmetros do método scheduleAtFixedRate são o tempo que ele vai esperar para iniciar a execução e o tempo entre a execução sucessiva da tarefa, no código abaixo a cada 500 milissegundos.
Timer().scheduleAtFixedRate(1, 500) {
...
}
TODO 4.1: adicionar o código para usar o modelo. Primeiro, carregue a gravação em um tensor de áudio e depois a transmita para o classificador:
tensor.load(record)
val output = classifier.classify(tensor)
TODO 4.2 para ter melhores resultados de inferência, você vai filtrar qualquer classificação com uma probabilidade muito baixa. Aqui, você usará a variável criada em uma etapa anterior (probabilityThreshold):
val filteredModelOutput = output[0].categories.filter {
it.score > probabilityThreshold
}
TODO 4.3:para facilitar a leitura do resultado, vamos criar uma string com os resultados filtrados:
val outputStr = filteredModelOutput.sortedBy { -it.score }
.joinToString(separator = "\n") { "${it.label} -> ${it.score} " }
TODO 4.4 Atualizar a IU. Neste app muito simples, o resultado é exibido apenas em uma TextView. Como a classificação não está na linha de execução principal, você precisará usar um gerenciador para fazer essa atualização.
runOnUiThread {
textView.text = outputStr
}
Você adicionou todo o código necessário para:
- Carregar o modelo da pasta de recursos
- Criar um gravador de áudio com a configuração correta
- Como executar inferência
- Mostrar os melhores resultados na tela
Agora, você só precisa testar o app.
8. Executar o app final
Como você integrou o modelo de classificação de áudio ao app, vamos testá-lo.
Conecte seu dispositivo Android e clique em "Run" (
) na barra de ferramentas do Android Studio.
Na primeira execução, você precisará conceder ao app permissões de gravação de áudio.
Depois de conceder a permissão, o app inicial usará o microfone do smartphone. Para testar, comece a falar perto do smartphone, já que uma das classes detectadas pela YAMNet é fala. Outra classe fácil de testar é estalar os dedos ou bater palmas.
Você também pode tentar detectar os latidos de um cachorro e muitos outros eventos possíveis (521). Para ver uma lista completa, confira o código-fonte ou leia os metadados com o arquivo de rótulos diretamente.
9. Parabéns!
Neste codelab, você aprendeu a encontrar um modelo pré-treinado para classificação de áudio e a implantá-lo no seu app para dispositivos móveis usando o TensorFlow Lite. Para saber mais sobre o TFLite, veja outras amostras do TFLite.
O que vimos
- Como implantar um modelo do TensorFlow Lite em um app Android.
- Como encontrar e usar modelos do TensorFlow Hub.
Próximas etapas
- Personalize o modelo com seus próprios dados.
Saiba mais
- Documentação do TensorFlow Lite
- Biblioteca de Suporte do TensorFlow Lite
- Biblioteca de tarefas do TensorFlow Lite
- Documentação do TensorFlow Hub
- Tecnologias de machine learning no dispositivo com o Google