O uso de processadores especializados, como GPUs, NPUs ou DSPs para aceleração de hardware pode melhorar drasticamente o desempenho de inferência (até 10 vezes mais rápido em alguns casos) e a experiência do usuário no seu aplicativo Android habilitado para ML. No entanto, devido à variedade de hardware e drivers que seus usuários podem ter, escolher a configuração ideal de aceleração de hardware para o dispositivo de cada usuário pode ser um desafio. Além disso, ativar a configuração errada em um dispositivo pode criar uma experiência do usuário ruim devido à alta latência ou, em alguns casos raros, a erros de tempo de execução ou problemas de precisão causados por incompatibilidades de hardware.
O Acceleration Service para Android é uma API que ajuda a escolher a
configuração ideal de aceleração de hardware para um determinado dispositivo de usuário e seu
modelo .tflite, minimizando o risco de erro de execução ou problemas de precisão.
O Acceleration Service avalia diferentes configurações de aceleração em dispositivos de usuários executando comparações de inferência internas com o modelo do TensorFlow Lite. Essas execuções de teste normalmente são concluídas em alguns segundos, dependendo do modelo. É possível executar as comparações uma vez em cada dispositivo do usuário antes do tempo de inferência, armazenar o resultado em cache e usá-lo durante a inferência. Essas comparações são executadas fora do processo, o que minimiza o risco de falhas no app.
Forneça o modelo, as amostras de dados e os resultados esperados (entradas e saídas "douradas") e o Acceleration Service executará uma comparação de inferência interna do TFLite para fornecer recomendações de hardware.
O serviço de aceleração faz parte da pilha de ML personalizada do Android e funciona com o TensorFlow Lite no Google Play Services.
Adicionar as dependências ao projeto
Adicione as seguintes dependências ao arquivo build.gradle do aplicativo:
implementation "com.google.android.gms:play-services-tflite-
acceleration-service:16.0.0-beta01"
A API Acceleration Service funciona com o TensorFlow Lite no Google Play Services. Se você ainda não estiver usando o ambiente de execução do TensorFlow Lite fornecido pelo Google Play Services, será necessário atualizar suas dependências.
Como usar a API Acceleration Service
Para usar o Acceleration Service, comece criando a configuração de aceleração
que você quer avaliar para seu modelo (por exemplo, GPU com OpenGL). Em seguida, crie uma configuração de validação com seu modelo, alguns dados de amostra e a saída do modelo esperada. Por fim, chame validateConfig() para transmitir as
configurações de aceleração e de validação.
Criar configurações de aceleração
As configurações de aceleração são representações das configurações de hardware que são convertidas em delegados durante o ambiente de execução. O serviço de aceleração usará essas configurações internamente para realizar inferências de teste.
No momento, o serviço de aceleração permite avaliar as configurações da GPU (convertidas em delegado de GPU durante o tempo de execução) com o GpuAccelerationConfig e a inferência de CPU (com CpuAccelerationConfig). Estamos trabalhando para que mais delegados possam acessar outros hardwares no futuro.
Configuração da aceleração de GPU
Crie uma configuração de aceleração de GPU da seguinte maneira:
AccelerationConfig accelerationConfig = new GpuAccelerationConfig.Builder()
.setEnableQuantizedInference(false)
.build();
Especifique se o modelo está usando ou não a quantização com setEnableQuantizedInference().
Configuração da aceleração da CPU
Crie a aceleração da CPU da seguinte maneira:
AccelerationConfig accelerationConfig = new CpuAccelerationConfig.Builder()
.setNumThreads(2)
.build();
Use o método
setNumThreads()
para definir o número de linhas de execução que você quer usar para avaliar a inferência
da CPU.
Criar configurações de validação
As configurações de validação permitem definir como você quer que o serviço de aceleração avalie inferências. Você vai usá-los para transmitir:
- amostras de entrada
- dos resultados esperados,
- lógica de validação de acurácia.
Forneça amostras de entrada para as quais você espera um bom desempenho do modelo (também conhecidas como amostras "douradas").
Crie um
ValidationConfig
com
CustomValidationConfig.Builder
da seguinte maneira:
ValidationConfig validationConfig = new CustomValidationConfig.Builder()
.setBatchSize(5)
.setGoldenInputs(inputs)
.setGoldenOutputs(outputBuffer)
.setAccuracyValidator(new MyCustomAccuracyValidator())
.build();
Especifique o número de amostras douradas com
setBatchSize().
Transmita as entradas das suas amostras douradas usando
setGoldenInputs().
Forneça a saída esperada para a entrada transmitida com
setGoldenOutputs().
É possível definir um tempo máximo de inferência com setInferenceTimeoutMillis()
(5.000 ms por padrão). Se a inferência levar mais tempo do que o tempo definido,
a configuração será rejeitada.
Também é possível criar um AccuracyValidator personalizado
da seguinte maneira:
class MyCustomAccuracyValidator implements AccuracyValidator {
boolean validate(
BenchmarkResult benchmarkResult,
ByteBuffer[] goldenOutput) {
for (int i = 0; i < benchmarkResult.actualOutput().size(); i++) {
if (!goldenOutputs[i]
.equals(benchmarkResult.actualOutput().get(i).getValue())) {
return false;
}
}
return true;
}
}
Defina uma lógica de validação que funcione para seu caso de uso.
Se os dados de validação já estiverem incorporados no modelo, será possível usar
EmbeddedValidationConfig.
Gerar saídas de validação
As saídas douradas são opcionais e, desde que você forneça entradas douradas, o
Acceleration Service pode gerar internamente as saídas douradas. Você também pode
definir a configuração de aceleração usada para gerar essas saídas douradas
chamando setGoldenConfig():
ValidationConfig validationConfig = new CustomValidationConfig.Builder()
.setBatchSize(5)
.setGoldenInputs(inputs)
.setGoldenConfig(customCpuAccelerationConfig)
[...]
.build();
Validar a configuração da aceleração
Depois de criar uma configuração de aceleração e uma configuração de validação, você pode avaliá-las para seu modelo.
Verifique se o ambiente de execução do TensorFlow Lite com o Google Play Services está inicializado corretamente e se o delegado da GPU está disponível para o dispositivo. Para isso, execute:
TfLiteGpu.isGpuDelegateAvailable(context)
.onSuccessTask(gpuAvailable -> TfLite.initialize(context,
TfLiteInitializationOptions.builder()
.setEnableGpuDelegateSupport(gpuAvailable)
.build()
)
);
Instancie o AccelerationService
chamando AccelerationService.create().
Em seguida, você pode validar a configuração de aceleração para seu modelo chamando
validateConfig():
InterpreterApi interpreter;
InterpreterOptions interpreterOptions = InterpreterApi.Options();
AccelerationService.create(context)
.validateConfig(model, accelerationConfig, validationConfig)
.addOnSuccessListener(validatedConfig -> {
if (validatedConfig.isValid() && validatedConfig.benchmarkResult().hasPassedAccuracyTest()) {
interpreterOptions.setAccelerationConfig(validatedConfig);
interpreter = InterpreterApi.create(model, interpreterOptions);
});
Também é possível validar várias configurações chamando
validateConfigs()
e transmitindo um objeto Iterable<AccelerationConfig> como parâmetro.
validateConfig()retornará uma
Task<ValidatedAccelerationConfigResult>
da API Task
do Google Play Services, que permite
tarefas assíncronas.
Para receber o resultado da chamada de validação, adicione um
callback
addOnSuccessListener().
Usar a configuração validada no intérprete
Depois de verificar se o ValidatedAccelerationConfigResult retornado no
callback é válido, defina a configuração validada como uma configuração de aceleração
para seu intérprete chamando interpreterOptions.setAccelerationConfig().
Armazenamento da configuração em cache
É improvável que a configuração de aceleração ideal para seu modelo mude no dispositivo. Assim que você receber uma configuração de aceleração satisfatória,
armazene-a no dispositivo e deixe que o aplicativo a recupere e a use para
criar a InterpreterOptions durante as sessões a seguir, em vez de
executar outra validação. Os métodos serialize() e deserialize() em ValidatedAccelerationConfigResult facilitam o processo de armazenamento e recuperação.
Exemplo de aplicativo
Para analisar uma integração no local do serviço de aceleração, consulte o app de exemplo (link em inglês).
Limitações
O Acceleration Service tem as seguintes limitações atuais:
- No momento, apenas as configurações de aceleração de GPU e de CPU são compatíveis.
- Ele só é compatível com o TensorFlow Lite no Google Play Services e não é possível usá-lo se você estiver usando a versão em pacote do TensorFlow Lite.
- O SDK do serviço de aceleração só oferece suporte ao nível 22 da API e mais recentes.
Advertências
Revise as seguintes ressalvas com atenção, especialmente se você planeja usar esse SDK na produção:
Antes de sair da versão Beta e lançar a versão estável para a API Acceleration Service, vamos publicar um novo SDK que pode ter algumas diferenças do Beta atual. Para continuar usando o Serviço de aceleração, você precisará migrar para esse novo SDK e enviar uma atualização para o app em tempo hábil. Não fazer isso pode causar falhas, já que o SDK Beta pode não ser mais compatível com o Google Play Services depois de algum tempo.
Não há garantia de que um recurso específico na API Acceleration Service ou na API como um todo vai ficar disponível para todos os usuários. Ela pode permanecer na versão Beta indefinidamente, ser encerrada ou ser combinada com outros recursos em pacotes criados para públicos específicos de desenvolvedores. Alguns recursos com a API Acceleration Service ou a própria API inteira podem ficar com disponibilidade geral em algum momento, mas não há uma programação fixa para isso.
Termos e privacidade
Termos de Serviço
O uso das APIs Acceleration Service está sujeito aos Termos de Serviço das
APIs do Google.
Além disso, as APIs Acceleration Service estão atualmente na versão Beta.
Ao usá-las, você reconhece os possíveis problemas descritos na
seção "Advertências" acima e reconhece que o serviço de aceleração nem sempre
funciona como especificado.
Privacidade
Quando você usa as APIs Acceleration Service, o processamento dos dados de entrada (por exemplo, imagens, vídeos e textos) acontece totalmente no dispositivo, e o Acceleration Service
não envia esses dados para os servidores do Google. Assim, você pode usar nossas APIs
para processar dados de entrada que não podem sair do dispositivo.
As APIs do Acceleration Service podem entrar em contato com os servidores do Google periodicamente para
receber correções de bugs, modelos atualizados e informações sobre a compatibilidade
com aceleradores de hardware. As APIs do Acceleration Service também enviam métricas sobre
o desempenho e a utilização das APIs no seu app para o Google. O Google usa
esses dados de métricas para medir o desempenho, depurar, manter e melhorar as APIs,
além de detectar uso indevido ou abuso, conforme descrito em mais detalhes na nossa Política de
Privacidade.
Você é responsável por informar os usuários do seu app sobre o processamento
dos dados de métricas do serviço de aceleração, conforme exigido pela legislação aplicável.
Os dados que coletamos incluem o seguinte:
- Informações do dispositivo (como fabricante, modelo, versão do SO e build) e aceleradores de hardware de ML disponíveis (GPU e DSP). Eles são usados para diagnósticos e análise de uso.
- Informações do app (nome do pacote / ID do pacote, versão do app). Usado para diagnóstico e análise de uso.
- Configuração da API (como formato e resolução da imagem). Usado para diagnóstico e análise de uso.
- Tipo de evento (como inicialização, modelo de download, atualização, execução, detecção). Usado para diagnóstico e análise de uso.
- Códigos de erro. Usado para diagnóstico.
- Métricas de desempenho. Usado para diagnóstico.
- Identificadores por instalação que não identificam exclusivamente um usuário ou dispositivo físico. Usado para operação de configuração remota e análise de uso.
- Endereços IP do remetente da solicitação de rede. Usado para diagnósticos de Configuração remota. Os endereços IP coletados são retidos temporariamente.
Suporte e feedback
Você pode enviar feedback e receber suporte pelo Issue Tracker do TensorFlow. Relate problemas e receba solicitações de suporte usando o modelo de problemas do TensorFlow Lite no Google Play Services.