o uso de processadores especializados, como GPUs, NPUs ou DSPs para hardware a aceleração pode melhorar drasticamente o desempenho de inferência (até 10 vezes mais rápido) inferência em alguns casos) e a experiência do usuário do Android com ML ativado para o aplicativo. No entanto, devido à variedade de hardwares e drivers que os usuários escolher a configuração ideal de aceleração de hardware para os dispositivos em cada dispositivo pode ser desafiador. Além disso, ativar a configuração incorreta dispositivo pode criar uma experiência de usuário ruim devido à alta latência ou, em alguns casos raros, 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 você a escolher
configuração ideal de aceleração de hardware para um determinado dispositivo do usuário e seu
.tflite, minimizando o risco de erros de execução ou problemas de precisão.
O Acceleration Service avalia diferentes configurações de aceleração no usuário dispositivos executando comparativos de mercado de inferência interno com seu LiteRT um modelo de machine learning. Esses testes geralmente são concluídos em alguns segundos, dependendo um modelo de machine learning. É possível executar as comparações uma vez em cada dispositivo do usuário antes da inferência tempo de execução, armazenar em cache o resultado e usá-lo durante a inferência. Essas comparações são feitas fora do processo; o que minimiza o risco de falhas no seu app.
Forneça seu modelo, amostras de dados e resultados esperados (entradas douradas e saídas) e o Acceleration Service executará uma inferência interna do TFLite para fornecer recomendações de hardware.
O Acceleration Service faz parte da pilha de ML personalizada do Android e funciona com LiteRT 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 a LiteRT no Google Play Serviços. Se você ainda não estiver usando o tempo de execução LiteRT fornecido pelo Google Play Services, as dependencies precisam ser atualizadas.
Como usar a API Acceleration Service
Para usar o Acceleration Service, comece criando a configuração de aceleração
que você quer avaliar para o modelo (por exemplo, GPU com OpenGL). Em seguida, crie um
configuração de validação com o modelo, alguns dados de amostra e o
saída do modelo. Por fim, chame validateConfig() ao transmitir os dois
configuração 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 convertidos em delegados durante a execução. O Acceleration Service usará essas configurações internamente para realizar inferências de teste.
No momento, o serviço de aceleração permite avaliar configurações (convertidas em delegado da GPU durante o tempo de execução) com o GpuAccelerationConfig e inferência de CPU (com CpuAccelerationConfig). Estamos trabalhando para que mais delegados acessem outros hardwares na futuro.
Configuração de aceleração de GPU
Crie uma configuração de aceleração de GPU da seguinte maneira:
AccelerationConfig accelerationConfig = new GpuAccelerationConfig.Builder()
.setEnableQuantizedInference(false)
.build();
É necessário especificar se o modelo usa ou não a quantização com
setEnableQuantizedInference()
Configuração de aceleração da CPU
Crie a aceleração da CPU da seguinte maneira:
AccelerationConfig accelerationConfig = new CpuAccelerationConfig.Builder()
.setNumThreads(2)
.build();
Use o
setNumThreads()
para definir o número de linhas de execução que você quer usar para avaliar o uso da CPU
a inferência.
Criar configurações de validação
As configurações de validação permitem definir como você quer que o modelo Serviço para avaliar inferências. Você vai usá-las para transmitir:
- amostras de entrada,
- resultados esperados,
- lógica de validação de acurácia.
Forneça amostras de entrada para as quais você espera um bom desempenho seu modelo (também conhecidas como amostras “douradas”).
Crie um
ValidationConfig
com
CustomValidationConfig.Builder
da seguinte forma:
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()
Fornecer a saída esperada para a entrada transmitida com
setGoldenOutputs()
Você pode definir um tempo máximo de inferência com setInferenceTimeoutMillis()
(5.000 ms por padrão). Se a inferência demorar mais do que o tempo definido,
a configuração será rejeitada.
Também é possível criar um AccuracyValidator personalizado
da seguinte forma:
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 ao 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
define a configuração de aceleração usada para gerar essas saídas douradas ao
chamando setGoldenConfig():
ValidationConfig validationConfig = new CustomValidationConfig.Builder()
.setBatchSize(5)
.setGoldenInputs(inputs)
.setGoldenConfig(customCpuAccelerationConfig)
[...]
.build();
Validar a configuração do Acceleration
Depois de criar uma configuração de aceleração e uma configuração de validação, para que você possa avaliá-las para o modelo.
Verificar se o tempo de execução do LiteRT com o Google Play Services está correto inicializado e se o delegado da GPU está disponível para o dispositivo executando:
TfLiteGpu.isGpuDelegateAvailable(context)
.onSuccessTask(gpuAvailable -> TfLite.initialize(context,
TfLiteInitializationOptions.builder()
.setEnableGpuDelegateSupport(gpuAvailable)
.build()
)
);
Instancie o AccelerationService.
chame AccelerationService.create().
Em seguida, é possível validar a configuração de aceleração para o 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á um
Task<ValidatedAccelerationConfigResult>
do Google Play Services
API Task que permite
tarefas assíncronas.
Para obter o resultado da chamada de validação, adicione uma
addOnSuccessListener()
o retorno de chamada.
Usar a configuração validada no interpretador
Depois de verificar se o ValidatedAccelerationConfigResult retornou no
é válido, você pode definir a configuração validada como uma configuração de aceleração
para seu intérprete chamando interpreterOptions.setAccelerationConfig().
Armazenamento de configurações em cache
É improvável que a configuração de aceleração ideal para seu modelo mude em
o dispositivo. Depois de receber uma configuração de aceleração satisfatória,
deve armazená-lo no dispositivo e deixar seu aplicativo recuperá-lo e usá-lo para
crie sua InterpreterOptions durante as próximas sessões em vez de
executando outra validação. Os métodos serialize() e deserialize() na
ValidatedAccelerationConfigResult tornam o processo de armazenamento e recuperação
mais fácil.
Exemplo de aplicativo
Para analisar uma integração do Serviço de Aceleração in-situ, consulte o app de exemplo.
Limitações
No momento, o Acceleration Service tem as seguintes limitações:
- No momento, apenas as configurações de aceleração de GPU e CPU são compatíveis.
- Ele só é compatível com LiteRT no Google Play Services e não é possível use-o se estiver usando a versão empacotada do LiteRT.
- 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 advertências com atenção, especialmente se você estiver planejando para usar esse SDK na produção:
Antes de sair da versão Beta e lançar a versão estável para o a API Acceleration Service, vamos publicar um novo SDK que pode diferenças em relação à versão Beta atual. Para continuar usando o Serviço de aceleração, será necessário migrar para esse novo SDK e enviar uma atualizar seu app em tempo hábil. Não fazer isso pode causar falhas, pois o SDK Beta pode não ser mais compatível com o Google Play Services após algum tempo.
Não há garantia de que um recurso específico na API A API de serviço ou a API como um todo sempre terão disponibilidade geral. Ela podem permanecer na versão Beta indefinidamente, ser encerrados ou combinados com outros em pacotes projetados para públicos específicos de desenvolvedores. Algumas com a API Acceleration Service ou toda a API pode se tornarem disponibilidade geral, mas não há um cronograma fixo para isso.
Termos e privacidade
Termos de Serviço
O uso das APIs Acceleration Service está sujeito aos Termos de
Serviço.
Além disso, as APIs Acceleration Service estão na versão Beta
e, como tal, ao usá-lo, você reconhece os possíveis problemas descritos nos
Advertências acima e reconhece que o Serviço de Aceleração não pode
sempre terão o desempenho especificado.
Privacidade
Quando você usa as APIs do Acceleration Service, o processamento dos dados de entrada (por exemplo,
imagens, vídeo, texto) ocorre totalmente no dispositivo, e o Serviço de Aceleração
não envia esses dados aos servidores do Google. Por isso, você pode usar nossas APIs
para o processamento de dados de entrada que não podem sair do dispositivo.
As APIs do Serviço Acceleration podem entrar em contato com os servidores do Google periodicamente em
para receber correções de bugs, modelos atualizados e aceleradores de hardware
informações de compatibilidade. As APIs Acceleration Service também enviam métricas sobre
o desempenho e a utilização das APIs do seu app para o Google. O Google usa
esses dados de métricas para medir o desempenho, depurar, manter e melhorar as APIs,
e detectar uso indevido ou abuso, conforme descrito em nossa Central de
Política.
Você é responsável por informar os usuários sobre seu aplicativo sobre o processamento do Google
dos dados de métricas do Serviço de Aceleração, conforme exigido pela legislação aplicável.
Os dados que coletamos incluem:
- informações do dispositivo (como fabricante, modelo, versão do SO e build) aceleradores de hardware de ML (GPU e DSP) disponíveis. Usado para diagnósticos e e análise de uso.
- Informações do app (nome / ID do pacote, versão do app). Usado para diagnósticos e análises de uso.
- Configuração da API (como formato e resolução de imagens). Usado para diagnósticos e análises de uso.
- Tipo de evento (como inicialização, download do modelo, atualização, execução, detecção). Usado para diagnósticos 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 e uso remotos análise de dados em nuvem.
- Endereços IP do remetente da solicitação de rede. Usado para configuração remota diagnóstico. Os endereços IP coletados são retidos temporariamente.
Suporte e feedback
Use o Issue Tracker do TensorFlow para enviar feedback e receber suporte. Informe problemas e solicitações de suporte usando o modelo de problema para LiteRT no Google Play Services.