Drivers de API de redes neurais

Esta página fornece uma visão geral de como implementar um driver API de redes neurais (NNAPI). Para obter mais detalhes, consulte a documentação encontrada nos arquivos de definição HAL em hardware/interfaces/neuralnetworks . Um exemplo de implementação de driver está em frameworks/ml/nn/driver/sample .

Para obter mais informações sobre a API de Redes Neurais, consulte API de Redes Neurais .

Redes Neurais HAL

Nota: Esta página refere-se à versão 1.3 do HAL de Redes Neurais no AOSP. Se você estiver implementando um driver em outra versão, consulte a versão correspondente do HAL de Redes Neurais.

A HAL de Redes Neurais (NN) define uma abstração dos vários dispositivos , como unidades de processamento gráfico (GPUs) e processadores de sinais digitais (DSPs), que estão em um produto (por exemplo, um telefone ou tablet). Os drivers para esses dispositivos devem estar em conformidade com NN HAL. A interface é especificada nos arquivos de definição HAL em hardware/interfaces/neuralnetworks .

O fluxo geral da interface entre o framework e um driver é mostrado na figura 1.

Figura 1. Fluxo de Redes Neurais

Inicialização

Na inicialização, a estrutura consulta o driver quanto aos seus recursos usando IDevice::getCapabilities_1_3 . A estrutura @1.3::Capabilities inclui todos os tipos de dados e representa o desempenho não relaxado usando um vetor.

Para determinar como alocar cálculos aos dispositivos disponíveis, a estrutura usa os recursos para entender com que rapidez e eficiência energética cada driver pode executar uma execução. Para fornecer estas informações, o driver deve fornecer números de desempenho padronizados com base na execução de cargas de trabalho de referência.

Para determinar os valores que o driver retorna em resposta a IDevice::getCapabilities_1_3 , use o aplicativo de benchmark NNAPI para medir o desempenho dos tipos de dados correspondentes. Os modelos MobileNet v1 e v2, asr_float e tts_float são recomendados para medir o desempenho para valores de ponto flutuante de 32 bits e os modelos quantizados MobileNet v1 e v2 são recomendados para valores quantizados de 8 bits. Para obter mais informações, consulte Conjunto de testes de aprendizado de máquina Android .

No Android 9 e versões anteriores, a estrutura Capabilities inclui informações de desempenho do driver apenas para pontos flutuantes e tensores quantizados e não inclui tipos de dados escalares.

Como parte do processo de inicialização, a estrutura pode consultar mais informações, usando IDevice::getType , IDevice::getVersionString , IDevice:getSupportedExtensions e IDevice::getNumberOfCacheFilesNeeded .

Entre as reinicializações do produto, a estrutura espera que todas as consultas descritas nesta seção sempre relatem os mesmos valores para um determinado driver. Caso contrário, um aplicativo que usa esse driver poderá apresentar desempenho reduzido ou comportamento incorreto.

Compilação

A estrutura determina quais dispositivos usar quando recebe uma solicitação de um aplicativo. No Android 10, os aplicativos podem descobrir e especificar os dispositivos escolhidos pela estrutura. Para obter mais informações, consulte Descoberta e atribuição de dispositivos .

No momento da compilação do modelo, a estrutura envia o modelo para cada driver candidato chamando IDevice::getSupportedOperations_1_3 . Cada driver retorna uma matriz de booleanos indicando quais operações do modelo são suportadas. Um driver pode determinar que não pode dar suporte a uma determinada operação por vários motivos. Por exemplo:

• O driver não oferece suporte ao tipo de dados.
• O driver oferece suporte apenas a operações com parâmetros de entrada específicos. Por exemplo, um driver pode dar suporte a operações de convolução 3x3 e 5x5, mas não a operações de convolução 7x7.
• O driver tem restrições de memória que o impedem de manipular gráficos ou entradas grandes.

Durante a compilação, a entrada, a saída e os operandos internos do modelo, conforme descrito em OperandLifeTime , podem ter dimensões ou classificação desconhecidas. Para obter mais informações, consulte Formato de saída .

A estrutura instrui cada driver selecionado a se preparar para executar um subconjunto do modelo chamando IDevice::prepareModel_1_3 . Cada driver então compila seu subconjunto. Por exemplo, um driver pode gerar código ou criar uma cópia reordenada dos pesos. Como pode haver um tempo significativo entre a compilação do modelo e a execução das solicitações, recursos como grandes pedaços de memória do dispositivo não devem ser atribuídos durante a compilação.

Em caso de sucesso, o driver retorna um identificador @1.3::IPreparedModel . Se o driver retornar um código de falha ao preparar seu subconjunto do modelo, a estrutura executará o modelo inteiro na CPU.

Para reduzir o tempo usado para compilação quando um aplicativo é iniciado, um driver pode armazenar artefatos de compilação em cache. Para obter mais informações, consulte Cache de compilação .

Execução

Quando um aplicativo solicita que a estrutura execute uma solicitação, a estrutura chama o método HAL IPreparedModel::executeSynchronously_1_3 por padrão para executar uma execução síncrona em um modelo preparado. Uma solicitação também pode ser executada de forma assíncrona usando o método execute_1_3 , o método executeFenced (consulte Execução protegida ) ou executada usando uma execução intermitente .

As chamadas de execução síncronas melhoram o desempenho e reduzem a sobrecarga de threading em comparação com chamadas assíncronas porque o controle é retornado ao processo do aplicativo somente após a conclusão da execução. Isso significa que o driver não precisa de um mecanismo separado para notificar o processo do aplicativo de que uma execução foi concluída.

Com o método assíncrono execute_1_3 , o controle retorna ao processo do aplicativo após o início da execução, e o driver deve notificar a estrutura quando a execução for concluída, usando o @1.3::IExecutionCallback .

O parâmetro Request passado para o método execute lista os operandos de entrada e saída usados ​​para a execução. A memória que armazena os dados do operando deve usar a ordem da linha principal com a primeira dimensão iterando a mais lenta e não ter preenchimento no final de nenhuma linha. Para mais informações sobre os tipos de operandos, consulte Operandos .

Para drivers NN HAL 1.2 ou superior, quando uma solicitação é concluída, o status do erro, o formato de saída e as informações de tempo são retornados à estrutura. Durante a execução, a saída ou operandos internos do modelo podem ter uma ou mais dimensões desconhecidas ou classificação desconhecida. Quando pelo menos um operando de saída tiver uma dimensão ou classificação desconhecida, o driver deverá retornar informações de saída dimensionadas dinamicamente.

Para drivers com NN HAL 1.1 ou inferior, somente o status de erro é retornado quando uma solicitação é concluída. As dimensões dos operandos de entrada e saída devem ser totalmente especificadas para que a execução seja concluída com êxito. Os operandos internos podem ter uma ou mais dimensões desconhecidas, mas devem ter classificação especificada.

Para solicitações de usuários que abrangem vários drivers, o framework é responsável por reservar memória intermediária e por sequenciar as chamadas para cada driver.

Várias solicitações podem ser iniciadas em paralelo no mesmo @1.3::IPreparedModel . O driver pode executar solicitações em paralelo ou serializar as execuções.

A estrutura pode solicitar que um driver mantenha mais de um modelo preparado. Por exemplo, prepare o modelo m1 , prepare m2 , execute a solicitação r1 em m1 , execute r2 em m2 , execute r3 em m1 , execute r4 em m2 , libere (descrito em Limpeza ) m1 e libere m2 .

Para evitar uma primeira execução lenta que pode resultar em uma experiência ruim para o usuário (por exemplo, uma falha no primeiro quadro), o driver deve realizar a maioria das inicializações na fase de compilação. A inicialização na primeira execução deve ser limitada a ações que afetam negativamente a integridade do sistema quando executadas antecipadamente, como reservar grandes buffers temporários ou aumentar a frequência do clock de um dispositivo. Drivers que podem preparar apenas um número limitado de modelos simultâneos podem ter que inicializar na primeira execução.

No Android 10 ou superior, nos casos em que várias execuções com o mesmo modelo preparado são executadas em rápida sucessão, o cliente pode optar por usar um objeto de execução intermitente para se comunicar entre os processos do aplicativo e do driver. Para obter mais informações, consulte Execuções Burst e Filas de Mensagens Rápidas .

Para melhorar o desempenho de múltiplas execuções em rápida sucessão, o driver pode manter buffers temporários ou aumentar as taxas de clock. A criação de um thread watchdog é recomendada para liberar recursos se nenhuma nova solicitação for criada após um período fixo de tempo.

Observação: o suporte para chamadas de execução síncronas na camada HAL não depende de chamadas de execução síncronas na camada NDK.

Forma de saída

Para solicitações em que um ou mais operandos de saída não têm todas as dimensões especificadas, o driver deverá fornecer uma lista de formatos de saída contendo as informações de dimensão para cada operando de saída após a execução. Para obter mais informações sobre dimensões, consulte OutputShape .

Se uma execução falhar devido a um buffer de saída subdimensionado, o driver deverá indicar quais operandos de saída têm tamanho de buffer insuficiente na lista de formas de saída e deverá relatar o máximo de informações dimensionais possível, usando zero para dimensões desconhecidas.

Tempo

No Android 10, um aplicativo pode solicitar o tempo de execução se tiver especificado um único dispositivo para usar durante o processo de compilação. Para obter detalhes, consulte MeasureTiming e descoberta e atribuição de dispositivos . Neste caso, um driver NN HAL 1.2 deve medir a duração da execução ou reportar UINT64_MAX (para indicar que a duração não está disponível) ao executar uma solicitação. O condutor deve minimizar qualquer penalidade de desempenho resultante da medição da duração da execução.

O driver relata as seguintes durações em microssegundos na estrutura Timing :

• Tempo de execução no dispositivo: Não inclui o tempo de execução no driver, que é executado no processador host.
• Tempo de execução no driver: Inclui o tempo de execução no dispositivo.

Essas durações devem incluir o momento em que a execução é suspensa, por exemplo, quando a execução foi interrompida por outras tarefas ou quando está aguardando a disponibilização de um recurso.

Observação: embora o driver relate durações em microssegundos, a estrutura relata durações em nanossegundos (dimensionando as durações relatadas pelo driver).

Quando o driver não foi solicitado a medir a duração da execução ou quando há um erro de execução, o driver deverá relatar as durações como UINT64_MAX . Mesmo quando o driver foi solicitado a medir a duração da execução, ele pode reportar UINT64_MAX o tempo no dispositivo, o tempo no driver ou ambos. Quando o driver relata ambas as durações como um valor diferente de UINT64_MAX , o tempo de execução no driver deve ser igual ou superior ao tempo no dispositivo.

Execução cercada

No Android 11, a NNAPI permite que as execuções aguardem uma lista de identificadores sync_fence e, opcionalmente, retornem um objeto sync_fence , que é sinalizado quando a execução é concluída. Isso reduz a sobrecarga para modelos de sequência pequena e casos de uso de streaming. A execução protegida também permite uma interoperabilidade mais eficiente com outros componentes que podem sinalizar ou aguardar por sync_fence . Para obter mais informações sobre sync_fence , consulte Estrutura de sincronização .

Em uma execução protegida, a estrutura chama o método IPreparedModel::executeFenced para iniciar uma execução assíncrona e protegida em um modelo preparado com um vetor de cercas de sincronização para aguardar. Se a tarefa assíncrona for concluída antes do retorno da chamada, um identificador vazio poderá ser retornado para sync_fence . Um objeto IFencedExecutionCallback também deve ser retornado para permitir que a estrutura consulte o status do erro e informações de duração.

Após a conclusão de uma execução, os dois valores de tempo a seguir que medem a duração da execução podem ser consultados por meio de IFencedExecutionCallback::getExecutionInfo .

• timingLaunched : Duração desde quando executeFenced é chamado até quando executeFenced sinaliza o syncFence retornado.
• timingFenced : Duração desde o momento em que todos os limites de sincronização que a execução aguarda são sinalizados até quando executeFenced sinaliza o syncFence retornado.

Controle de fluxo

Para dispositivos com Android 11 ou superior, a NNAPI inclui duas operações de fluxo de controle, IF e WHILE , que usam outros modelos como argumentos e os executam condicionalmente ( IF ) ou repetidamente ( WHILE ). Para obter mais informações sobre como implementar isso, consulte Fluxo de controle .

Qualidade de serviço

No Android 11, a NNAPI inclui qualidade de serviço (QoS) aprimorada, permitindo que um aplicativo indique as prioridades relativas de seus modelos, o tempo máximo esperado para a preparação de um modelo e o tempo máximo esperado para uma execução. para ser concluído. Para obter mais informações, consulte Qualidade de serviço .

Limpar

Quando um aplicativo termina de usar um modelo preparado, a estrutura libera sua referência para o objeto @1.3::IPreparedModel . Quando o objeto IPreparedModel não é mais referenciado, ele é automaticamente destruído no serviço de driver que o criou. Os recursos específicos do modelo podem ser recuperados neste momento na implementação do destruidor do driver. Se o serviço de driver desejar que o objeto IPreparedModel seja destruído automaticamente quando não for mais necessário pelo cliente, ele não deverá conter nenhuma referência ao objeto IPreparedModel após o objeto IPreparedeModel ter sido retornado por meio de IPreparedModelCallback::notify_1_3 .

utilização do CPU

Espera-se que os drivers usem a CPU para configurar os cálculos. Os drivers não devem usar a CPU para realizar cálculos gráficos porque isso interfere na capacidade da estrutura de alocar trabalho corretamente. O driver deve relatar ao framework as partes que ele não consegue tratar e deixar que o framework cuide do resto.

A estrutura fornece uma implementação de CPU para todas as operações NNAPI, exceto para operações definidas pelo fornecedor. Para obter mais informações, consulte Extensões de fornecedor .

As operações introduzidas no Android 10 (API nível 29) possuem apenas uma implementação de CPU de referência para verificar se os testes CTS e VTS estão corretos. As implementações otimizadas incluídas em estruturas de aprendizado de máquina móvel são preferidas à implementação de CPU NNAPI.

Funções utilitárias

A base de código NNAPI inclui funções utilitárias que podem ser usadas por serviços de driver.

O arquivo frameworks/ml/nn/common/include/Utils.h contém diversas funções utilitárias, como aquelas usadas para registro e para conversão entre diferentes versões de NN HAL.

• VLogging: VLOG é uma macro wrapper em torno LOG do Android que apenas registra a mensagem se a tag apropriada estiver definida na propriedade debug.nn.vlog . initVLogMask() deve ser chamado antes de qualquer chamada para VLOG . A macro VLOG_IS_ON pode ser usada para verificar se VLOG está ativado no momento, permitindo que códigos de registro complicados sejam ignorados se não forem necessários. O valor do imóvel deverá ser um dos seguintes:

  • Uma string vazia, indicando que nenhum registro deve ser feito.
  • O token 1 ou all , indicando que todo o registro deve ser feito.
  • Uma lista de tags, delimitadas por espaços, vírgulas ou dois pontos, indicando qual registro deve ser feito. As tags são compilation , cpuexe , driver , execution , manager e model .

• compliantWithV1_* : Retorna true se um objeto NN HAL puder ser convertido para o mesmo tipo de uma versão HAL diferente sem perder informações. Por exemplo, chamar compliantWithV1_0 em um V1_2::Model retornará false se o modelo incluir tipos de operação introduzidos em NN HAL 1.1 ou NN HAL 1.2.

• convertToV1_* : Converte um objeto NN HAL de uma versão para outra. Um aviso será registrado se a conversão resultar em perda de informações (ou seja, se a nova versão do tipo não puder representar totalmente o valor).

• Capacidades: As funções nonExtensionOperandPerformance e update podem ser usadas para ajudar a construir o campo Capabilities::operandPerformance .

• Consultando propriedades de tipos: isExtensionOperandType , isExtensionOperationType , nonExtensionSizeOfData , nonExtensionOperandSizeOfData , nonExtensionOperandTypeIsScalar , tensorHasUnspecifiedDimensions .

O arquivo frameworks/ml/nn/common/include/ValidateHal.h contém funções utilitárias para validar se um objeto NN HAL é válido de acordo com a especificação de sua versão HAL.

• validate* : Retorna true se o objeto NN HAL for válido de acordo com a especificação de sua versão HAL. Os tipos OEM e os tipos de extensão não são validados. Por exemplo, validateModel retornará false se o modelo contiver uma operação que faça referência a um índice de operando que não existe ou uma operação que não seja suportada nessa versão HAL.

O arquivo frameworks/ml/nn/common/include/Tracing.h contém macros para simplificar a adição de informações de systracing ao código de redes neurais. Para obter um exemplo, consulte as invocações de macro NNTRACE_* no driver de amostra .

O arquivo frameworks/ml/nn/common/include/GraphDump.h contém uma função utilitária para despejar o conteúdo de um Model em formato gráfico para fins de depuração.

• graphDump : grava uma representação do modelo no formato Graphviz ( .dot ) no fluxo especificado (se fornecido) ou no logcat (se nenhum fluxo for fornecido).

Validação

Para testar sua implementação da NNAPI, use os testes VTS e CTS incluídos na estrutura do Android. O VTS exercita seus drivers diretamente (sem usar a estrutura), enquanto o CTS os exercita indiretamente por meio da estrutura. Eles testam cada método de API e verificam se todas as operações suportadas pelos drivers funcionam corretamente e fornecem resultados que atendem aos requisitos de precisão.

Os requisitos de precisão em CTS e VTS para NNAPI são os seguintes:

• Ponto flutuante: abs(esperado - real) <= atol + rtol * abs(esperado); onde:

  • Para fp32, atol = 1e-5f, rtol = 5,0f * 1,1920928955078125e-7
  • Para fp16, atol = rtol = 5,0f * 0,0009765625f

• Quantizado: desligado por um (exceto mobilenet_quantized , que é desligado por três)

• Booleano: correspondência exata

Uma maneira de o CTS testar a NNAPI é gerando gráficos pseudoaleatórios fixos usados ​​para testar e comparar os resultados de execução de cada driver com a implementação de referência da NNAPI. Para drivers com NN HAL 1.2 ou superior, se os resultados não atenderem aos critérios de precisão, o CTS reportará um erro e despejará um arquivo de especificação para o modelo com falha em /data/local/tmp para depuração. Para obter mais detalhes sobre os critérios de precisão, consulte TestRandomGraph.cpp e TestHarness.h .

Teste de difusão

O objetivo do teste fuzz é encontrar travamentos, asserções, violações de memória ou comportamento geral indefinido no código em teste devido a fatores como entradas inesperadas. Para testes de difusão NNAPI, o Android usa testes baseados em libFuzzer , que são eficientes na difusão porque usam cobertura de linha de casos de teste anteriores para gerar novas entradas aleatórias. Por exemplo, libFuzzer favorece casos de teste executados em novas linhas de código. Isso reduz bastante o tempo que os testes levam para encontrar o código problemático.

Para realizar testes fuzz para validar a implementação do driver, modifique frameworks/ml/nn/runtime/test/android_fuzzing/DriverFuzzTest.cpp no ​​utilitário de teste libneuralnetworks_driver_fuzzer encontrado no AOSP para incluir o código do driver. Para obter mais informações sobre testes fuzz NNAPI, consulte frameworks/ml/nn/runtime/test/android_fuzzing/README.md .

Segurança

Como os processos de aplicativos se comunicam diretamente com o processo de um driver, os drivers devem validar os argumentos das chamadas que recebem. Esta validação é verificada pelo VTS. O código de validação está em frameworks/ml/nn/common/include/ValidateHal.h .

Os motoristas também devem garantir que os aplicativos não interfiram em outros aplicativos ao usar o mesmo dispositivo.

Conjunto de testes de aprendizado de máquina Android

O Android Machine Learning Test Suite (MLTS) é um benchmark NNAPI incluído no CTS e VTS para validar a precisão de modelos reais em dispositivos de fornecedores. O benchmark avalia a latência e a precisão e compara os resultados dos drivers com os resultados do TF Lite rodando na CPU, para o mesmo modelo e conjuntos de dados. Isso garante que a precisão do driver não seja pior que a implementação de referência da CPU.

Os desenvolvedores da plataforma Android também usam MLTS para avaliar a latência e a precisão dos drivers.

O benchmark NNAPI pode ser encontrado em dois projetos no AOSP:

• platform/test/mlts/benchmark (aplicativo de referência)
• platform/test/mlts/models (modelos e conjuntos de dados)

Modelos e conjuntos de dados

O benchmark NNAPI usa os seguintes modelos e conjuntos de dados.

• MobileNetV1 float e u8 quantizados em tamanhos diferentes, executados em um pequeno subconjunto (1.500 imagens) do Open Images Dataset v4.
• MobileNetV2 float e u8 quantizados em tamanhos diferentes, executados em um pequeno subconjunto (1.500 imagens) do Open Images Dataset v4.
• Modelo acústico baseado em memória de longo e curto prazo (LSTM) para conversão de texto em fala, executado em um pequeno subconjunto do conjunto CMU Arctic.
• Modelo acústico baseado em LSTM para reconhecimento automático de fala, executado em um pequeno subconjunto do conjunto de dados LibriSpeech.

Para obter mais informações, consulte platform/test/mlts/models .

Teste de estresse

O Android Machine Learning Test Suite inclui uma série de testes de colisão para validar a resiliência dos drivers sob condições de uso intenso ou em casos extremos de comportamento dos clientes.

Todos os testes de colisão fornecem os seguintes recursos:

• Detecção de travamento: se o cliente NNAPI travar durante um teste, o teste falhará com o motivo de falha HANG e o conjunto de testes passará para o próximo teste.
• Detecção de falha do cliente NNAPI: os testes sobrevivem às falhas do cliente e os testes falham com o motivo da falha CRASH .
• Detecção de falha de driver: os testes podem detectar uma falha de driver que causa falha em uma chamada NNAPI. Observe que pode haver falhas nos processos do driver que não causam falha na NNAPI e não causam falha no teste. Para cobrir esse tipo de falha, é recomendado executar o comando tail no log do sistema para erros ou travamentos relacionados ao driver.
• Direcionamento de todos os aceleradores disponíveis: os testes são executados em todos os drivers disponíveis.

Todos os testes de colisão têm os seguintes quatro resultados possíveis:

• SUCCESS : Execução concluída sem erro.
• FAILURE : Falha na execução. Normalmente causado por uma falha ao testar um modelo, indicando que o driver falhou ao compilar ou executar o modelo.
• HANG : O processo de teste parou de responder.
• CRASH : O processo de teste travou.

Para obter mais informações sobre testes de estresse e uma lista completa de testes de colisão, consulte platform/test/mlts/benchmark/README.txt .

Usar MLTS

Para usar o MLTS:

1. Conecte um dispositivo de destino à sua estação de trabalho e verifique se ele pode ser acessado por meio de adb . Exporte a variável de ambiente ANDROID_SERIAL do dispositivo de destino se mais de um dispositivo estiver conectado.

2. cd no diretório de origem de nível superior do Android.

   source build/envsetup.sh
   lunch aosp_arm-userdebug # Or aosp_arm64-userdebug if available.
   ./test/mlts/benchmark/build_and_run_benchmark.sh
   

   No final de uma execução de benchmark, os resultados são apresentados como uma página HTML e passados ​​para xdg-open .

Para obter mais informações, consulte platform/test/mlts/benchmark/README.txt .

Versões HAL de redes neurais

Esta seção descreve as alterações introduzidas nas versões HAL do Android e das redes neurais.

Android 11

O Android 11 apresenta o NN HAL 1.3, que inclui as seguintes alterações notáveis.

• Suporte para quantização assinada de 8 bits em NNAPI. Adiciona o tipo de operando TENSOR_QUANT8_ASYMM_SIGNED . Drivers com NN HAL 1.3 que suportam operações com quantização não assinada também devem suportar as variantes assinadas dessas operações. Ao executar versões assinadas e não assinadas da maioria das operações quantizadas, os drivers devem produzir os mesmos resultados até um deslocamento de 128. Há cinco exceções a esse requisito: CAST , HASHTABLE_LOOKUP , LSH_PROJECTION , PAD_V2 e QUANTIZED_16BIT_LSTM . A operação QUANTIZED_16BIT_LSTM não suporta operandos assinados e as outras quatro operações suportam quantização assinada, mas não exigem que os resultados sejam iguais.
• Suporte para execuções protegidas em que a estrutura chama o método IPreparedModel::executeFenced para iniciar uma execução assíncrona e protegida em um modelo preparado com um vetor de cercas de sincronização para aguardar. Para obter mais informações, consulte Execução cercada .
• Suporte para fluxo de controle. Adiciona as operações IF e WHILE , que tomam outros modelos como argumentos e os executam condicionalmente ( IF ) ou repetidamente ( WHILE ). Para obter mais informações, consulte Fluxo de controle .
• Melhor qualidade de serviço (QoS), pois os aplicativos podem indicar as prioridades relativas de seus modelos, o tempo máximo esperado para a preparação de um modelo e o tempo máximo esperado para a conclusão de uma execução. Para obter mais informações, consulte Qualidade de serviço .
• Suporte para domínios de memória que fornecem interfaces de alocador para buffers gerenciados por driver. Isso permite a passagem de memórias nativas do dispositivo entre execuções, suprimindo cópias e transformações desnecessárias de dados entre execuções consecutivas no mesmo driver. Para obter mais informações, consulte Domínios de memória .

Android 10

O Android 10 apresenta o NN HAL 1.2, que inclui as seguintes alterações notáveis.

• A estrutura Capabilities inclui todos os tipos de dados, incluindo tipos de dados escalares, e representa o desempenho não relaxado usando um vetor em vez de campos nomeados.
• Os métodos getVersionString e getType permitem que a estrutura recupere o tipo de dispositivo ( DeviceType ) e informações de versão. Consulte Descoberta e atribuição de dispositivos .
• O método executeSynchronously é chamado por padrão para executar uma execução de forma síncrona. O método execute_1_2 informa ao framework para realizar uma execução de forma assíncrona. Veja Execução .
• O parâmetro MeasureTiming para executeSynchronously , execute_1_2 e execução intermitente especifica se o driver deve medir a duração da execução. Os resultados são relatados na estrutura Timing . Consulte Tempo .
• Suporte para execuções em que um ou mais operandos de saída possuem dimensão ou classificação desconhecida. Consulte Formato de saída .
• Suporte para extensões de fornecedor, que são coleções de operações e tipos de dados definidos pelo fornecedor. O driver relata extensões suportadas por meio do método IDevice::getSupportedExtensions . Consulte Extensões de Fornecedores .
• Capacidade de um objeto burst controlar um conjunto de execuções burst usando filas de mensagens rápidas (FMQs) para se comunicar entre processos de aplicativo e driver, reduzindo a latência. Consulte Execuções Burst e Filas de Mensagens Rápidas .
• Suporte para AHardwareBuffer para permitir que o driver execute execuções sem copiar dados. Consulte AHardwareBuffer .
• Suporte aprimorado para armazenamento em cache de artefatos de compilação para reduzir o tempo usado para compilação quando um aplicativo é iniciado. Consulte Cache de Compilação .

O Android 10 apresenta os seguintes tipos e operações de operandos.

• Tipos de operandos

  • ANEURALNETWORKS_BOOL
  • ANEURALNETWORKS_FLOAT16
  • ANEURALNETWORKS_TENSOR_BOOL8
  • ANEURALNETWORKS_TENSOR_FLOAT16
  • ANEURALNETWORKS_TENSOR_QUANT16_ASYMM
  • ANEURALNETWORKS_TENSOR_QUANT16_SYMM
  • ANEURALNETWORKS_TENSOR_QUANT8_SYMM
  • ANEURALNETWORKS_TENSOR_QUANT8_SYMM_PER_CHANNEL

• Operações

  • ANEURALNETWORKS_ABS
  • ANEURALNETWORKS_ARGMAX
  • ANEURALNETWORKS_ARGMIN
  • ANEURALNETWORKS_AXIS_ALIGNED_BBOX_TRANSFORM
  • ANEURALNETWORKS_BIDIRECTIONAL_SEQUENCE_LSTM
  • ANEURALNETWORKS_BIDIRECTIONAL_SEQUENCE_RNN
  • ANEURALNETWORKS_BOX_WITH_NMS_LIMIT
  • ANEURALNETWORKS_CAST
  • ANEURALNETWORKS_CHANNEL_SHUFFLE
  • ANEURALNETWORKS_DETECTION_POSTPROCESSING
  • ANEURALNETWORKS_EQUAL
  • ANEURALNETWORKS_EXP
  • ANEURALNETWORKS_EXPAND_DIMS
  • ANEURALNETWORKS_GATHER
  • ANEURALNETWORKS_GENERATE_PROPOSALS
  • ANEURALNETWORKS_GREATER
  • ANEURALNETWORKS_GREATER_EQUAL
  • ANEURALNETWORKS_GROUPED_CONV_2D
  • ANEURALNETWORKS_HEATMAP_MAX_KEYPOINT
  • ANEURALNETWORKS_INSTANCE_NORMALIZATION
  • ANEURALNETWORKS_LESS
  • ANEURALNETWORKS_LESS_EQUAL
  • ANEURALNETWORKS_LOG
  • ANEURALNETWORKS_LOGICAL_AND
  • ANEURALNETWORKS_LOGICAL_NOT
  • ANEURALNETWORKS_LOGICAL_OR
  • ANEURALNETWORKS_LOG_SOFTMAX
  • ANEURALNETWORKS_MAXIMUM
  • ANEURALNETWORKS_MINIMUM
  • ANEURALNETWORKS_NEG
  • ANEURALNETWORKS_NOT_EQUAL
  • ANEURALNETWORKS_PAD_V2
  • ANEURALNETWORKS_POW
  • ANEURALNETWORKS_PRELU
  • ANEURALNETWORKS_QUANTIZE
  • ANEURALNETWORKS_QUANTIZED_16BIT_LSTM
  • ANEURALNETWORKS_RANDOM_MULTINOMIAL
  • ANEURALNETWORKS_REDUCE_ALL
  • ANEURALNETWORKS_REDUCE_ANY
  • ANEURALNETWORKS_REDUCE_MAX
  • ANEURALNETWORKS_REDUCE_MIN
  • ANEURALNETWORKS_REDUCE_PROD
  • ANEURALNETWORKS_REDUCE_SUM
  • ANEURALNETWORKS_RESIZE_NEAREST_NEIGHBOR
  • ANEURALNETWORKS_ROI_ALIGN
  • ANEURALNETWORKS_ROI_POOLING
  • ANEURALNETWORKS_RSQRT
  • ANEURALNETWORKS_SELECT
  • ANEURALNETWORKS_SIN
  • ANEURALNETWORKS_SLICE
  • ANEURALNETWORKS_SPLIT
  • ANEURALNETWORKS_SQRT
  • ANEURALNETWORKS_TILE
  • ANEURALNETWORKS_TOPK_V2
  • ANEURALNETWORKS_TRANSPOSE_CONV_2D
  • ANEURALNETWORKS_UNIDIRECTIONAL_SEQUENCE_LSTM
  • ANEURALNETWORKS_UNIDIRECTIONAL_SEQUENCE_RNN

O Android 10 apresenta atualizações para muitas das operações existentes. As atualizações estão relacionadas principalmente ao seguinte:

• Suporte para o layout de memória NCHW
• Suporte para tensores com classificação diferente de 4 em operações softmax e normalização
• Suporte para convoluções dilatadas
• Suporte para entradas com quantização mista em ANEURALNETWORKS_CONCATENATION

A lista abaixo mostra as operações modificadas no Android 10. Para obter detalhes completos das alterações, consulte OperationCode na documentação de referência da NNAPI.

• ANEURALNETWORKS_ADD
• ANEURALNETWORKS_AVERAGE_POOL_2D
• ANEURALNETWORKS_BATCH_TO_SPACE_ND
• ANEURALNETWORKS_CONCATENATION
• ANEURALNETWORKS_CONV_2D
• ANEURALNETWORKS_DEPTHWISE_CONV_2D
• ANEURALNETWORKS_DEPTH_TO_SPACE
• ANEURALNETWORKS_DEQUANTIZE
• ANEURALNETWORKS_DIV
• ANEURALNETWORKS_FLOOR
• ANEURALNETWORKS_FULLY_CONNECTED
• ANEURALNETWORKS_L2_NORMALIZATION
• ANEURALNETWORKS_L2_POOL_2D
• ANEURALNETWORKS_LOCAL_RESPONSE_NORMALIZATION
• ANEURALNETWORKS_LOGISTIC
• ANEURALNETWORKS_LSH_PROJECTION
• ANEURALNETWORKS_LSTM
• ANEURALNETWORKS_MAX_POOL_2D
• ANEURALNETWORKS_MEAN
• ANEURALNETWORKS_MUL
• ANEURALNETWORKS_PAD
• ANEURALNETWORKS_RELU
• ANEURALNETWORKS_RELU1
• ANEURALNETWORKS_RELU6
• ANEURALNETWORKS_RESHAPE
• ANEURALNETWORKS_RESIZE_BILINEAR
• ANEURALNETWORKS_RNN
• ANEURALNETWORKS_ROI_ALIGN
• ANEURALNETWORKS_SOFTMAX
• ANEURALNETWORKS_SPACE_TO_BATCH_ND
• ANEURALNETWORKS_SPACE_TO_DEPTH
• ANEURALNETWORKS_SQUEEZE
• ANEURALNETWORKS_STRIDED_SLICE
• ANEURALNETWORKS_SUB
• ANEURALNETWORKS_SVDF
• ANEURALNETWORKS_TANH
• ANEURALNETWORKS_TRANSPOSE

Android 9

NN HAL 1.1 é introduzido no Android 9 e inclui as seguintes alterações notáveis.

• IDevice::prepareModel_1_1 inclui um parâmetro ExecutionPreference . Um motorista pode usar isso para ajustar sua preparação, sabendo que o aplicativo prefere economizar bateria ou executará o modelo em chamadas rápidas e sucessivas.
• Nove novas operações foram adicionadas: BATCH_TO_SPACE_ND , DIV , MEAN , PAD , SPACE_TO_BATCH_ND , SQUEEZE , STRIDED_SLICE , SUB , TRANSPOSE .
• Um aplicativo pode especificar que cálculos flutuantes de 32 bits podem ser executados usando intervalo flutuante e/ou precisão de 16 bits definindo Model.relaxComputationFloat32toFloat16 como true . A estrutura Capabilities possui o campo adicional relaxedFloat32toFloat16Performance para que o driver possa relatar seu desempenho relaxado à estrutura.

Android 8.1

O HAL inicial de redes neurais (1.0) foi lançado no Android 8.1. Para obter mais informações, consulte /neuralnetworks/1.0/ .