API Neural Networks

L'API Android Neural Networks (NNAPI) è un'API Android C progettata per l'esecuzione di operazioni ad alta intensità di calcolo per il machine learning su dispositivi Android. L'NNAPI è progettata per fornire un livello di funzionalità di base per i framework di machine learning di livello superiore, come TensorFlow Lite e Caffe2, che creano e addestrano le reti neurali. L'API è disponibile su tutti i dispositivi Android con Android 8.1 (livello API 27) o versioni successive, ma è stata ritirata in Android 15.

NNAPI supporta l'inferenza applicando i dati dei dispositivi Android a modelli precedentemente addestrati e definiti dagli sviluppatori. Esempi di inferenza includono la classificazione di immagini, la previsione del comportamento degli utenti e la selezione di risposte appropriate a una query di ricerca.

L'inferenza on-device offre molti vantaggi:

  • Latenza: non è necessario inviare una richiesta tramite una connessione di rete e attendere una risposta. Ad esempio, questo può essere fondamentale per le applicazioni video che elaborano fotogrammi successivi provenienti da una videocamera.
  • Disponibilità: l'applicazione viene eseguita anche al di fuori della copertura di rete.
  • Velocità: il nuovo hardware specifico per l'elaborazione delle reti neurali fornisce un calcolo significativamente più veloce rispetto a una CPU per uso generico da sola.
  • Privacy: i dati non vengono trasferiti dal dispositivo Android.
  • Costo: non è necessaria alcuna server farm quando tutti i calcoli vengono eseguiti sul dispositivo Android.

Ci sono anche dei compromessi che uno sviluppatore deve tenere presente:

  • Utilizzo del sistema: la valutazione delle reti neurali comporta un'elevata quantità di calcoli, che potrebbe aumentare l'utilizzo della batteria. Se questo è un problema per la tua app, ti consigliamo di monitorare lo stato della batteria, soprattutto per i calcoli di lunga durata.
  • Dimensioni dell'applicazione: presta attenzione alle dimensioni dei modelli. I modelli possono occupare diversi megabyte di spazio. Se l'inserimento di modelli di grandi dimensioni nell'APK influisce negativamente sugli utenti, ti consigliamo di scaricare i modelli dopo l'installazione dell'app, di utilizzare modelli più piccoli o di eseguire i calcoli nel cloud. NNAPI non fornisce funzionalità per l'esecuzione di modelli nel cloud.

Consulta l'esempio di API Android Neural Networks per vedere un esempio di come utilizzare l'NNAPI.

Informazioni sul runtime dell'API Neural Networks

NNAPI è pensata per essere chiamata da librerie, framework e strumenti di machine learning che consentono agli sviluppatori di addestrare i propri modelli off-device ed eseguirne il deployment su dispositivi Android. In genere, le app non utilizzano direttamente l'NNAPI, ma framework di machine learning di livello superiore. Questi framework, a loro volta, potrebbero utilizzare NNAPI per eseguire operazioni di inferenza con accelerazione hardware sui dispositivi supportati.

In base ai requisiti di un'app e alle funzionalità hardware di un dispositivo Android, il runtime della rete neurale di Android può distribuire in modo efficiente il workload di calcolo tra i processori disponibili per l'elaborazione su dispositivo, tra cui hardware di rete neurale dedicato, unità di elaborazione grafica (GPU) e processori di segnale digitale (DSP).

Per i dispositivi Android che non dispongono di un driver del fornitore specializzato, il runtime NNAPI esegue le richieste sulla CPU.

La Figura 1 mostra l'architettura di sistema di alto livello per NNAPI.

Figura 1. Architettura di sistema per l'API Android Neural Networks

Modello di programmazione dell'API Neural Networks

Per eseguire calcoli utilizzando NNAPI, devi prima creare un grafo orientato che definisca i calcoli da eseguire. Questo grafico di calcolo, combinato con i dati di input (ad esempio, i pesi e i bias trasmessi da un framework di machine learning), forma il modello per la valutazione del runtime NNAPI.

NNAPI utilizza quattro astrazioni principali:

  • Modello: un grafico di calcolo delle operazioni matematiche e dei valori costanti appresi tramite un processo di addestramento. Queste operazioni sono specifiche per le reti neurali. Questi includono la convoluzione bidimensionale (2D), l'attivazione logistica (sigmoide), l'attivazione lineare rettificata (ReLU) e altro ancora. La creazione di un modello è un'operazione sincrona. Una volta creato, può essere riutilizzato in thread e raccolte. In NNAPI, un modello è rappresentato come un'istanza ANeuralNetworksModel.
  • Compilazione: rappresenta una configurazione per la compilazione di un modello NNAPI in codice di livello inferiore. La creazione di una compilazione è un'operazione sincrona. Una volta creato, può essere riutilizzato in più thread ed esecuzioni. In NNAPI, ogni compilazione è rappresentata come un'istanza ANeuralNetworksCompilation.
  • Memoria: rappresenta la memoria condivisa, i file mappati in memoria e buffer di memoria simili. L'utilizzo di un buffer di memoria consente al runtime NNAPI di trasferire i dati ai driver in modo più efficiente. In genere, un'app crea un buffer di memoria condivisa che contiene tutti i tensori necessari per definire un modello. Puoi anche utilizzare i buffer di memoria per archiviare gli input e gli output di un'istanza di esecuzione. In NNAPI, ogni buffer di memoria è rappresentato come un'istanza ANeuralNetworksMemory.

  • Esecuzione: interfaccia per applicare un modello NNAPI a un insieme di input e raccogliere i risultati. L'esecuzione può essere eseguita in modo sincrono o asincrono.

    Per l'esecuzione asincrona, più thread possono attendere la stessa esecuzione. Al termine di questa esecuzione, tutti i thread vengono rilasciati.

    In NNAPI, ogni esecuzione è rappresentata come un'istanza ANeuralNetworksExecution.

La Figura 2 mostra il flusso di programmazione di base.

Figura 2. Flusso di programmazione per l'API Android Neural Networks

Il resto di questa sezione descrive i passaggi per configurare il modello NNAPI per eseguire il calcolo, compilare il modello ed eseguire il modello compilato.

Fornisci l'accesso ai dati di addestramento

I dati relativi a pesi e bias addestrati sono probabilmente archiviati in un file. Per fornire al runtime NNAPI un accesso efficiente a questi dati, crea un'istanza ANeuralNetworksMemory chiamando la funzione ANeuralNetworksMemory_createFromFd() e passando il descrittore del file di dati aperto. Specifichi anche i flag di protezione della memoria e un offset in cui inizia la regione di memoria condivisa nel file.

// Create a memory buffer from the file that contains the trained data
ANeuralNetworksMemory* mem1 = NULL;
int fd = open("training_data", O_RDONLY);
ANeuralNetworksMemory_createFromFd(file_size, PROT_READ, fd, 0, &mem1);

Anche se in questo esempio utilizziamo una sola istanza ANeuralNetworksMemory per tutti i nostri pesi, è possibile utilizzare più di un'istanza ANeuralNetworksMemory per più file.

Utilizza buffer hardware nativi

Puoi utilizzare i buffer hardware nativi per gli input, gli output e i valori degli operandi costanti del modello. In alcuni casi, un acceleratore NNAPI può accedere agli oggetti AHardwareBuffer senza che il driver debba copiare i dati. AHardwareBuffer ha molte configurazioni diverse e non tutti gli acceleratori NNAPI potrebbero supportarle tutte. A causa di questa limitazione, consulta i vincoli elencati nella documentazione di riferimento di ANeuralNetworksMemory_createFromAHardwareBuffer ed esegui i test in anticipo sui dispositivi di destinazione per assicurarti che le compilazioni e le esecuzioni che utilizzano AHardwareBuffer si comportino come previsto, utilizzando l'assegnazione dei dispositivi per specificare l'acceleratore.

Per consentire al runtime NNAPI di accedere a un oggetto AHardwareBuffer, crea un'istanza ANeuralNetworksMemory chiamando la funzione ANeuralNetworksMemory_createFromAHardwareBuffer e passando l'oggetto AHardwareBuffer, come mostrato nell'esempio di codice seguente:

// Configure and create AHardwareBuffer object
AHardwareBuffer_Desc desc = ...
AHardwareBuffer* ahwb = nullptr;
AHardwareBuffer_allocate(&desc, &ahwb);

// Create ANeuralNetworksMemory from AHardwareBuffer
ANeuralNetworksMemory* mem2 = NULL;
ANeuralNetworksMemory_createFromAHardwareBuffer(ahwb, &mem2);

Quando NNAPI non ha più bisogno di accedere all'oggetto AHardwareBuffer, libera l'istanza ANeuralNetworksMemory corrispondente:

ANeuralNetworksMemory_free(mem2);

Nota

  • Puoi utilizzare AHardwareBuffer solo per l'intero buffer; non puoi utilizzarlo con un parametro ARect.
  • Il runtime NNAPI non svuoterà il buffer. Devi assicurarti che i buffer di input e output siano accessibili prima di pianificare l'esecuzione.
  • Non è previsto il supporto per i descrittori dei file di sincronizzazione.
  • Per un AHardwareBuffer con formati e bit di utilizzo specifici del fornitore, spetta all'implementazione del fornitore determinare se il client o il driver è responsabile dello svuotamento della cache.

Modello

Un modello è l'unità fondamentale di calcolo in NNAPI. Ogni modello è definito da uno o più operandi e operazioni.

Operandi

Gli operandi sono oggetti di dati utilizzati per definire il grafico. Questi includono gli input e gli output del modello, i nodi intermedi che contengono i dati che passano da un'operazione all'altra e le costanti che vengono passate a queste operazioni.

Esistono due tipi di operandi che possono essere aggiunti ai modelli NNAPI: scalari e tensori.

Uno scalare rappresenta un singolo valore. NNAPI supporta valori scalari nei formati booleano, rappresentazione in virgola mobile a 16 bit, rappresentazione in virgola mobile a 32 bit, numero intero a 32 bit e numero intero senza segno a 32 bit.

La maggior parte delle operazioni in NNAPI coinvolge i tensori. I tensori sono array n-dimensionali. NNAPI supporta tensori con valori in virgola mobile a 16 bit, in virgola mobile a 32 bit, quantizzati a 8 bit, quantizzati a 16 bit, interi a 32 bit e booleani a 8 bit.

Ad esempio, la figura 3 rappresenta un modello con due operazioni: un'addizione seguita da una moltiplicazione. Il modello accetta un tensore di input e produce un tensore di output.

Figura 3. Esempio di operandi per un modello NNAPI

Il modello sopra ha sette operandi. Questi operandi vengono identificati implicitamente dall'indice dell'ordine in cui vengono aggiunti al modello. Il primo operando aggiunto ha un indice pari a 0, il secondo un indice pari a 1 e così via. Gli operandi 1, 2, 3 e 5 sono operandi costanti.

L'ordine in cui aggiungi gli operandi non è importante. Ad esempio, l'operando di output del modello potrebbe essere il primo aggiunto. L'importante è utilizzare il valore di indice corretto quando si fa riferimento a un operando.

Gli operandi hanno dei tipi. Questi vengono specificati quando vengono aggiunti al modello.

Un operando non può essere utilizzato sia come input sia come output di un modello.

Ogni operando deve essere un input del modello, una costante o l'operando di output di esattamente un'operazione.

Per ulteriori informazioni sull'utilizzo degli operandi, consulta Scopri di più sugli operandi.

Operazioni

Un'operazione specifica i calcoli da eseguire. Ogni operazione è costituita dai seguenti elementi:

  • un tipo di operazione (ad esempio addizione, moltiplicazione, convoluzione),
  • un elenco di indici degli operandi utilizzati dall'operazione per l'input e
  • un elenco di indici degli operandi utilizzati dall'operazione per l'output.

L'ordine in questi elenchi è importante. Consulta il Riferimento API NNAPI per gli input e gli output previsti per ogni tipo di operazione.

Prima di aggiungere l'operazione, devi aggiungere al modello gli operandi che un'operazione utilizza o produce.

L'ordine in cui aggiungi le operazioni non è importante. NNAPI si basa sulle dipendenze stabilite dal grafico di calcolo degli operandi e delle operazioni per determinare l'ordine in cui vengono eseguite le operazioni.

Le operazioni supportate da NNAPI sono riassunte nella tabella seguente:

Categoria Operazioni
Operazioni matematiche per elementi
Manipolazione dei tensori
Operazioni sulle immagini
Operazioni di ricerca
Operazioni di normalizzazione
Operazioni di convoluzione
Operazioni di pooling
Operazioni di attivazione
Altre operazioni

Problema noto nel livello API 28: quando si passano tensori ANEURALNETWORKS_TENSOR_QUANT8_ASYMM all'operazione ANEURALNETWORKS_PAD, disponibile su Android 9 (livello API 28) e versioni successive, l'output di NNAPI potrebbe non corrispondere all'output di framework di machine learning di livello superiore, come TensorFlow Lite. Dovresti invece passare solo ANEURALNETWORKS_TENSOR_FLOAT32. Il problema è stato risolto in Android 10 (livello API 29) e versioni successive.

Crea modelli

Nell'esempio seguente, creiamo il modello a due operazioni mostrato nella figura 3.

Per creare il modello, segui questi passaggi:

  1. Chiama la funzione ANeuralNetworksModel_create() per definire un modello vuoto.

    ANeuralNetworksModel* model = NULL;
ANeuralNetworksModel_create(&model);

  2. Aggiungi gli operandi al modello chiamando ANeuralNetworks_addOperand(). I tipi di dati sono definiti utilizzando la struttura di dati ANeuralNetworksOperandType.

    // In our example, all our tensors are matrices of dimension [3][4]
ANeuralNetworksOperandType tensor3x4Type;
tensor3x4Type.type = ANEURALNETWORKS_TENSOR_FLOAT32;
tensor3x4Type.scale = 0.f;    // These fields are used for quantized tensors
tensor3x4Type.zeroPoint = 0;  // These fields are used for quantized tensors
tensor3x4Type.dimensionCount = 2;
uint32_t dims[2] = {3, 4};
tensor3x4Type.dimensions = dims;

    
// We also specify operands that are activation function specifiers
ANeuralNetworksOperandType activationType;
activationType.type = ANEURALNETWORKS_INT32;
activationType.scale = 0.f;
activationType.zeroPoint = 0;
activationType.dimensionCount = 0;
activationType.dimensions = NULL;

    
// Now we add the seven operands, in the same order defined in the diagram
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 0
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 1
ANeuralNetworksModel_addOperand(model, &activationType); // operand 2
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 3
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 4
ANeuralNetworksModel_addOperand(model, &activationType); // operand 5
ANeuralNetworksModel_addOperand(model, &tensor3x4Type);  // operand 6

  3. Per gli operandi con valori costanti, come pesi e bias che la tua app ottiene da un processo di addestramento, utilizza le funzioni ANeuralNetworksModel_setOperandValue() e ANeuralNetworksModel_setOperandValueFromMemory().

    Nell'esempio seguente, impostiamo i valori costanti dal file dei dati di addestramento corrispondente al buffer di memoria che abbiamo creato in Fornisci l'accesso ai dati di addestramento.

    // In our example, operands 1 and 3 are constant tensors whose values were
// established during the training process
const int sizeOfTensor = 3 * 4 * 4;    // The formula for size calculation is dim0 * dim1 * elementSize
ANeuralNetworksModel_setOperandValueFromMemory(model, 1, mem1, 0, sizeOfTensor);
ANeuralNetworksModel_setOperandValueFromMemory(model, 3, mem1, sizeOfTensor, sizeOfTensor);

    
// We set the values of the activation operands, in our example operands 2 and 5
int32_t noneValue = ANEURALNETWORKS_FUSED_NONE;
ANeuralNetworksModel_setOperandValue(model, 2, &noneValue, sizeof(noneValue));
ANeuralNetworksModel_setOperandValue(model, 5, &noneValue, sizeof(noneValue));

  4. Per ogni operazione nel grafo orientato che vuoi calcolare, aggiungi l'operazione al modello chiamando la funzione ANeuralNetworksModel_addOperation().

    Come parametri di questa chiamata, l'app deve fornire:

    • il tipo di operazione
    • il conteggio dei valori di input
    • l'array degli indici per gli operandi di input
    • il conteggio dei valori di output
    • l'array degli indici per gli operandi di output

    Tieni presente che un operando non può essere utilizzato sia per l'input che per l'output della stessa operazione.

    // We have two operations in our example
// The first consumes operands 1, 0, 2, and produces operand 4
uint32_t addInputIndexes[3] = {1, 0, 2};
uint32_t addOutputIndexes[1] = {4};
ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_ADD, 3, addInputIndexes, 1, addOutputIndexes);

    
// The second consumes operands 3, 4, 5, and produces operand 6
uint32_t multInputIndexes[3] = {3, 4, 5};
uint32_t multOutputIndexes[1] = {6};
ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_MUL, 3, multInputIndexes, 1, multOutputIndexes);

  5. Identifica gli operandi che il modello deve trattare come input e output chiamando la funzione ANeuralNetworksModel_identifyInputsAndOutputs().

    // Our model has one input (0) and one output (6)
uint32_t modelInputIndexes[1] = {0};
uint32_t modelOutputIndexes[1] = {6};
ANeuralNetworksModel_identifyInputsAndOutputs(model, 1, modelInputIndexes, 1 modelOutputIndexes);

  6. Facoltativamente, specifica se ANEURALNETWORKS_TENSOR_FLOAT32 può essere calcolato con un intervallo o una precisione pari a quelli del formato di rappresentazione in virgola mobile a 16 bit IEEE 754 chiamando ANeuralNetworksModel_relaxComputationFloat32toFloat16().

  7. Chiama ANeuralNetworksModel_finish() per finalizzare la definizione del modello. Se non ci sono errori, questa funzione restituisce un codice risultato ANEURALNETWORKS_NO_ERROR.

    ANeuralNetworksModel_finish(model);

Una volta creato un modello, puoi compilarlo un numero qualsiasi di volte ed eseguire ogni compilazione un numero qualsiasi di volte.

Flusso di controllo

Per incorporare il flusso di controllo in un modello NNAPI, segui questi passaggi:

  1. Crea i sottografi di esecuzione corrispondenti (sottografi then e else per un'istruzione IF, sottografi condition e body per un loop WHILE) come modelli ANeuralNetworksModel* autonomi:

    ANeuralNetworksModel* thenModel = makeThenModel();
ANeuralNetworksModel* elseModel = makeElseModel();

  2. Crea operandi che fanno riferimento a questi modelli all'interno del modello contenente il flusso di controllo:

    ANeuralNetworksOperandType modelType = {
    .type = ANEURALNETWORKS_MODEL,
};
ANeuralNetworksModel_addOperand(model, &modelType);  // kThenOperandIndex
ANeuralNetworksModel_addOperand(model, &modelType);  // kElseOperandIndex
ANeuralNetworksModel_setOperandValueFromModel(model, kThenOperandIndex, &thenModel);
ANeuralNetworksModel_setOperandValueFromModel(model, kElseOperandIndex, &elseModel);

  3. Aggiungi l'operazione del flusso di controllo: 

    uint32_t inputs[] = {kConditionOperandIndex,
                     kThenOperandIndex,
                     kElseOperandIndex,
                     kInput1, kInput2, kInput3};
uint32_t outputs[] = {kOutput1, kOutput2};
ANeuralNetworksModel_addOperation(model, ANEURALNETWORKS_IF,
                                  std::size(inputs), inputs,
                                  std::size(output), outputs);

Compilation

Il passaggio di compilazione determina su quali processori verrà eseguito il modello e chiede ai driver corrispondenti di prepararsi per l'esecuzione. Ciò potrebbe includere la generazione di codice macchina specifico per i processori su cui verrà eseguito il modello.

Per compilare un modello:

  1. Chiama la funzione ANeuralNetworksCompilation_create() per creare una nuova istanza di compilazione.

    // Compile the model
ANeuralNetworksCompilation* compilation;
ANeuralNetworksCompilation_create(model, &compilation);

    Se vuoi, puoi utilizzare l'assegnazione dei dispositivi per scegliere esplicitamente su quali dispositivi eseguire l'operazione.

  2. Se vuoi, puoi influenzare il modo in cui il runtime bilancia l'utilizzo della batteria e la velocità di esecuzione. Puoi farlo chiamando il numero ANeuralNetworksCompilation_setPreference().

    // Ask to optimize for low power consumption
ANeuralNetworksCompilation_setPreference(compilation, ANEURALNETWORKS_PREFER_LOW_POWER);

    Le preferenze che puoi specificare includono:

    • ANEURALNETWORKS_PREFER_LOW_POWER: preferisci l'esecuzione in modo da ridurre al minimo il consumo della batteria. Questo è auspicabile per le compilazioni eseguite di frequente.
    • ANEURALNETWORKS_PREFER_FAST_SINGLE_ANSWER: preferisce restituire una singola risposta il più rapidamente possibile, anche se ciò comporta un consumo energetico maggiore. Questa è l'impostazione predefinita.
    • ANEURALNETWORKS_PREFER_SUSTAINED_SPEED: preferisce massimizzare il throughput dei frame successivi, ad esempio durante l'elaborazione dei frame successivi provenienti dalla fotocamera.

  3. Se vuoi, puoi configurare la memorizzazione nella cache della compilazione chiamando ANeuralNetworksCompilation_setCaching.

    // Set up compilation caching
ANeuralNetworksCompilation_setCaching(compilation, cacheDir, token);

    Utilizza getCodeCacheDir() per cacheDir. Il valore token specificato deve essere univoco per ogni modello all'interno dell'applicazione.

  4. Completa la definizione della compilazione chiamando ANeuralNetworksCompilation_finish(). Se non sono presenti errori, questa funzione restituisce un codice risultato ANEURALNETWORKS_NO_ERROR.

    ANeuralNetworksCompilation_finish(compilation);

Rilevamento e assegnazione dei dispositivi

Sui dispositivi Android con Android 10 (livello API 29) e versioni successive, NNAPI fornisce funzioni che consentono alle librerie e alle app del framework di machine learning di ottenere informazioni sui dispositivi disponibili e di specificare i dispositivi da utilizzare per l'esecuzione. Fornire informazioni sui dispositivi disponibili consente alle app di ottenere la versione esatta dei driver presenti su un dispositivo per evitare incompatibilità note. Offrendo alle app la possibilità di specificare quali dispositivi devono eseguire diverse sezioni di un modello, le app possono essere ottimizzate per il dispositivo Android su cui viene eseguito il deployment.

Rilevamento dispositivi

Utilizza ANeuralNetworks_getDeviceCount per ottenere il numero di dispositivi disponibili. Per ogni dispositivo, utilizza ANeuralNetworks_getDevice per impostare un'istanza ANeuralNetworksDevice su un riferimento a quel dispositivo.

Una volta ottenuto un riferimento al dispositivo, puoi trovare ulteriori informazioni su questo dispositivo utilizzando le seguenti funzioni:

Assegnazione dei dispositivi

Utilizza ANeuralNetworksModel_getSupportedOperationsForDevices per scoprire quali operazioni di un modello possono essere eseguite su dispositivi specifici.

Per controllare quali acceleratori utilizzare per l'esecuzione, chiama ANeuralNetworksCompilation_createForDevices al posto di ANeuralNetworksCompilation_create. Utilizza l'oggetto ANeuralNetworksCompilation risultante come di consueto. La funzione restituisce un errore se il modello fornito contiene operazioni non supportate dai dispositivi selezionati.

Se vengono specificati più dispositivi, il runtime è responsabile della distribuzione del lavoro tra i dispositivi.

Analogamente ad altri dispositivi, l'implementazione della CPU NNAPI è rappresentata da un ANeuralNetworksDevice con il nome nnapi-reference e il tipo ANEURALNETWORKS_DEVICE_TYPE_CPU. Quando chiami ANeuralNetworksCompilation_createForDevices, l'implementazione della CPU non viene utilizzata per gestire i casi di errore per la compilazione e l'esecuzione del modello.

È responsabilità di un'applicazione suddividere un modello in sottomodelli che possono essere eseguiti sui dispositivi specificati. Le applicazioni che non richiedono il partizionamento manuale devono continuare a chiamare il metodo più semplice ANeuralNetworksCompilation_create per utilizzare tutti i dispositivi disponibili (inclusa la CPU) per accelerare il modello. Se il modello non può essere completamente supportato dai dispositivi specificati utilizzando ANeuralNetworksCompilation_createForDevices, viene restituito ANEURALNETWORKS_BAD_DATA.

Partizionamento del modello

Quando sono disponibili più dispositivi per il modello, il runtime NNAPI distribuisce il lavoro tra i dispositivi. Ad esempio, se a ANeuralNetworksCompilation_createForDevices sono stati forniti più dispositivi, verranno presi in considerazione tutti quelli specificati durante l'assegnazione del lavoro. Tieni presente che, se il dispositivo CPU non è presente nell'elenco, l'esecuzione della CPU verrà disattivata. Quando utilizzi ANeuralNetworksCompilation_create, verranno presi in considerazione tutti i dispositivi disponibili, inclusa la CPU.

La distribuzione viene eseguita selezionando dall'elenco dei dispositivi disponibili, per ciascuna delle operazioni nel modello, il dispositivo che supporta l'operazione e che dichiara le prestazioni migliori, ovvero il tempo di esecuzione più rapido o il consumo energetico più basso, a seconda della preferenza di esecuzione specificata dal client. Questo algoritmo di partizionamento non tiene conto di possibili inefficienze causate dall'I/O tra i diversi processori, pertanto, quando specifichi più processori (in modo esplicito quando utilizzi ANeuralNetworksCompilation_createForDevices o in modo implicito utilizzando ANeuralNetworksCompilation_create), è importante profilare l'applicazione risultante.

Per capire come è stato partizionato il modello da NNAPI, controlla i log di Android per trovare un messaggio (a livello INFO con tag ExecutionPlan):

ModelBuilder::findBestDeviceForEachOperation(op-name): device-index

op-name è il nome descrittivo dell'operazione nel grafico e device-index è l'indice del dispositivo candidato nell'elenco dei dispositivi. Questo elenco è l'input fornito a ANeuralNetworksCompilation_createForDevices o, se utilizzi ANeuralNetworksCompilation_createForDevices, l'elenco dei dispositivi restituito durante l'iterazione di tutti i dispositivi utilizzando ANeuralNetworks_getDeviceCount e ANeuralNetworks_getDevice.

Il messaggio (a livello INFO con tag ExecutionPlan):

ModelBuilder::partitionTheWork: only one best device: device-name

Questo messaggio indica che l'intero grafico è stato accelerato sul dispositivo device-name.

Esecuzione

Il passaggio di esecuzione applica il modello a un insieme di input e memorizza gli output di calcolo in uno o più buffer utente o spazi di memoria allocati dalla tua app.

Per eseguire un modello compilato, segui questi passaggi:

  1. Chiama la funzione ANeuralNetworksExecution_create() per creare una nuova istanza di esecuzione.

    // Run the compiled model against a set of inputs
ANeuralNetworksExecution* run1 = NULL;
ANeuralNetworksExecution_create(compilation, &run1);

  2. Specifica dove l'app legge i valori di input per il calcolo. L'app può leggere i valori di input da un buffer utente o da uno spazio di memoria allocato chiamando rispettivamente ANeuralNetworksExecution_setInput() o ANeuralNetworksExecution_setInputFromMemory().

    // Set the single input to our sample model. Since it is small, we won't use a memory buffer
float32 myInput[3][4] = { ...the data... };
ANeuralNetworksExecution_setInput(run1, 0, NULL, myInput, sizeof(myInput));

  3. Specifica dove l'app scrive i valori di output. La tua app può scrivere i valori di output in un buffer utente o in uno spazio di memoria allocato, chiamando rispettivamente ANeuralNetworksExecution_setOutput() o ANeuralNetworksExecution_setOutputFromMemory().

    // Set the output
float32 myOutput[3][4];
ANeuralNetworksExecution_setOutput(run1, 0, NULL, myOutput, sizeof(myOutput));

  4. Pianifica l'avvio dell'esecuzione chiamando la funzione ANeuralNetworksExecution_startCompute(). Se non sono presenti errori, questa funzione restituisce un codice risultato ANEURALNETWORKS_NO_ERROR.

    // Starts the work. The work proceeds asynchronously
ANeuralNetworksEvent* run1_end = NULL;
ANeuralNetworksExecution_startCompute(run1, &run1_end);

  5. Chiama la funzione ANeuralNetworksEvent_wait() per attendere il completamento dell'esecuzione. Se l'esecuzione è andata a buon fine, questa funzione restituisce un codice risultato ANEURALNETWORKS_NO_ERROR. L'attesa può essere eseguita su un thread diverso da quello che avvia l'esecuzione.

    // For our example, we have no other work to do and will just wait for the completion
ANeuralNetworksEvent_wait(run1_end);
ANeuralNetworksEvent_free(run1_end);
ANeuralNetworksExecution_free(run1);

  6. Facoltativamente, puoi applicare un insieme diverso di input al modello compilato utilizzando la stessa istanza di compilazione per creare una nuova istanza ANeuralNetworksExecution.

    // Apply the compiled model to a different set of inputs
ANeuralNetworksExecution* run2;
ANeuralNetworksExecution_create(compilation, &run2);
ANeuralNetworksExecution_setInput(run2, ...);
ANeuralNetworksExecution_setOutput(run2, ...);
ANeuralNetworksEvent* run2_end = NULL;
ANeuralNetworksExecution_startCompute(run2, &run2_end);
ANeuralNetworksEvent_wait(run2_end);
ANeuralNetworksEvent_free(run2_end);
ANeuralNetworksExecution_free(run2);

Esecuzione sincrona

L'esecuzione asincrona impiega tempo per generare e sincronizzare i thread. Inoltre, la latenza può essere estremamente variabile, con i ritardi più lunghi che raggiungono fino a 500 microsecondi tra il momento in cui un thread viene notificato o attivato e il momento in cui viene infine associato a un core della CPU.

Per migliorare la latenza, puoi invece indirizzare un'applicazione a effettuare una chiamata di inferenza sincrona al runtime. La chiamata verrà restituita solo al termine di un'inferenza, anziché all'avvio di un'inferenza. Anziché chiamare ANeuralNetworksExecution_startCompute per una chiamata di inferenza asincrona al runtime, l'applicazione chiama ANeuralNetworksExecution_compute per effettuare una chiamata sincrona al runtime. Una chiamata a ANeuralNetworksExecution_compute non accetta un ANeuralNetworksEvent e non è accoppiata a una chiamata a ANeuralNetworksEvent_wait.

Esecuzioni in burst

Sui dispositivi Android con Android 10 (livello API 29) e versioni successive, l'NNAPI supporta le esecuzioni in burst tramite l'oggetto ANeuralNetworksBurst. Le esecuzioni in burst sono una sequenza di esecuzioni della stessa compilazione che si verificano in rapida successione, ad esempio quelle che operano sui frame di un'acquisizione della fotocamera o su campioni audio successivi. L'utilizzo di oggetti ANeuralNetworksBurst può comportare esecuzioni più rapide, in quanto indicano agli acceleratori che le risorse possono essere riutilizzate tra le esecuzioni e che gli acceleratori devono rimanere in uno stato di prestazioni elevate per la durata del burst.

ANeuralNetworksBurst introduce solo una piccola modifica nel percorso di esecuzione normale. Puoi creare un oggetto burst utilizzando ANeuralNetworksBurst_create, come mostrato nel seguente snippet di codice:

// Create burst object to be reused across a sequence of executions
ANeuralNetworksBurst* burst = NULL;
ANeuralNetworksBurst_create(compilation, &burst);

Le esecuzioni in burst sono sincrone. Tuttavia, invece di utilizzare ANeuralNetworksExecution_compute per eseguire ogni inferenza, accoppi i vari oggetti ANeuralNetworksExecution con lo stesso ANeuralNetworksBurst nelle chiamate alla funzione ANeuralNetworksExecution_burstCompute.

// Create and configure first execution object
// ...

// Execute using the burst object
ANeuralNetworksExecution_burstCompute(execution1, burst);

// Use results of first execution and free the execution object
// ...

// Create and configure second execution object
// ...

// Execute using the same burst object
ANeuralNetworksExecution_burstCompute(execution2, burst);

// Use results of second execution and free the execution object
// ...

Libera l'oggetto ANeuralNetworksBurst con ANeuralNetworksBurst_free quando non è più necessario.

// Cleanup
ANeuralNetworksBurst_free(burst);

Code di comandi asincrone ed esecuzione con barriera

In Android 11 e versioni successive, NNAPI supporta un modo aggiuntivo per pianificare l'esecuzione asincrona tramite il metodo ANeuralNetworksExecution_startComputeWithDependencies(). Quando utilizzi questo metodo, l'esecuzione attende che tutti gli eventi dipendenti vengano segnalati prima di avviare la valutazione. Una volta completata l'esecuzione e quando gli output sono pronti per essere utilizzati, viene segnalato l'evento restituito.

A seconda dei dispositivi che gestiscono l'esecuzione, l'evento potrebbe essere supportato da un sync fence. Devi chiamare ANeuralNetworksEvent_wait() per attendere l'evento e recuperare le risorse utilizzate dall'esecuzione. Puoi importare i sync fence in un oggetto evento utilizzando ANeuralNetworksEvent_createFromSyncFenceFd() ed esportarli da un oggetto evento utilizzando ANeuralNetworksEvent_getSyncFenceFd().

Output con dimensioni dinamiche

Per supportare i modelli in cui le dimensioni dell'output dipendono dai dati di input, ovvero in cui le dimensioni non possono essere determinate al momento dell'esecuzione del modello, utilizza ANeuralNetworksExecution_getOutputOperandRank e ANeuralNetworksExecution_getOutputOperandDimensions.

Il seguente esempio di codice mostra come eseguire questa operazione:

// Get the rank of the output
uint32_t myOutputRank = 0;
ANeuralNetworksExecution_getOutputOperandRank(run1, 0, &myOutputRank);

// Get the dimensions of the output
std::vector<uint32_t> myOutputDimensions(myOutputRank);
ANeuralNetworksExecution_getOutputOperandDimensions(run1, 0, myOutputDimensions.data());

Esegui la pulizia

Il passaggio di pulizia gestisce la liberazione delle risorse interne utilizzate per il calcolo.

// Cleanup
ANeuralNetworksCompilation_free(compilation);
ANeuralNetworksModel_free(model);
ANeuralNetworksMemory_free(mem1);

Gestione degli errori e fallback della CPU

Se si verifica un errore durante il partizionamento, se un driver non riesce a compilare un modello (o una parte di un modello) o se un driver non riesce a eseguire un modello compilato (o una parte di un modello), NNAPI potrebbe tornare alla propria implementazione della CPU di una o più operazioni.

Se il client NNAPI contiene versioni ottimizzate dell'operazione (come, ad esempio, TFLite), potrebbe essere utile disattivare il fallback della CPU e gestire gli errori con l'implementazione dell'operazione ottimizzata del client.

In Android 10, se la compilazione viene eseguita utilizzando ANeuralNetworksCompilation_createForDevices, il fallback della CPU verrà disattivato.

In Android P, l'esecuzione di NNAPI torna alla CPU se l'esecuzione sul driver non va a buon fine. Questo vale anche per Android 10 quando viene utilizzato ANeuralNetworksCompilation_create anziché ANeuralNetworksCompilation_createForDevices.

La prima esecuzione viene eseguita in modalità di riserva per quella singola partizione e, se l'operazione non va a buon fine, riprova l'intero modello sulla CPU.

Se il partizionamento o la compilazione non vanno a buon fine, l'intero modello verrà provato sulla CPU.

In alcuni casi, alcune operazioni non sono supportate sulla CPU e, in queste situazioni, la compilazione o l'esecuzione non andrà a buon fine anziché eseguire il fallback.

Anche dopo aver disattivato il fallback della CPU, nel modello potrebbero essere ancora presenti operazioni pianificate sulla CPU. Se la CPU è nell'elenco dei processori forniti a ANeuralNetworksCompilation_createForDevices ed è l'unico processore che supporta queste operazioni o è il processore che dichiara le migliori prestazioni per queste operazioni, verrà scelta come esecutore principale (non di riserva).

Per assicurarti che non venga eseguita alcuna CPU, utilizza ANeuralNetworksCompilation_createForDevices escludendo nnapi-reference dall'elenco dei dispositivi. A partire da Android P, è possibile disattivare il fallback in fase di esecuzione sulle build di DEBUG impostando la proprietà debug.nn.partition su 2.

Domini di memoria

In Android 11 e versioni successive, NNAPI supporta i domini di memoria che forniscono interfacce di allocatore per le memorie opache. In questo modo, le applicazioni possono passare memorie native del dispositivo tra le esecuzioni, in modo che NNAPI non copi o trasformi i dati inutilmente durante l'esecuzione di esecuzioni consecutive sullo stesso driver.

La funzionalità del dominio di memoria è destinata ai tensori che sono per lo più interni al driver e che non richiedono un accesso frequente al lato client. Esempi di questi tensori includono i tensori di stato nei modelli di sequenza. Per i tensori che richiedono un accesso frequente alla CPU sul lato client, utilizza invece i pool di memoria condivisa.

Per allocare una memoria opaca, segui questi passaggi:

  1. Chiama la funzione ANeuralNetworksMemoryDesc_create() per creare un nuovo descrittore di memoria:

    // Create a memory descriptor
ANeuralNetworksMemoryDesc* desc;
ANeuralNetworksMemoryDesc_create(&desc);

  2. Specifica tutti i ruoli di input e output previsti chiamando ANeuralNetworksMemoryDesc_addInputRole() e ANeuralNetworksMemoryDesc_addOutputRole().

    // Specify that the memory may be used as the first input and the first output
// of the compilation
ANeuralNetworksMemoryDesc_addInputRole(desc, compilation, 0, 1.0f);
ANeuralNetworksMemoryDesc_addOutputRole(desc, compilation, 0, 1.0f);

  3. Facoltativamente, specifica le dimensioni della memoria chiamando ANeuralNetworksMemoryDesc_setDimensions().

    // Specify the memory dimensions
uint32_t dims[] = {3, 4};
ANeuralNetworksMemoryDesc_setDimensions(desc, 2, dims);

  4. Completa la definizione del descrittore chiamando ANeuralNetworksMemoryDesc_finish().

    ANeuralNetworksMemoryDesc_finish(desc);

  5. Alloca tutte le memorie di cui hai bisogno passando il descrittore a ANeuralNetworksMemory_createFromDesc().

    // Allocate two opaque memories with the descriptor
ANeuralNetworksMemory* opaqueMem;
ANeuralNetworksMemory_createFromDesc(desc, &opaqueMem);

  6. Libera il descrittore di memoria quando non ti serve più.

    ANeuralNetworksMemoryDesc_free(desc);

Il client può utilizzare l'oggetto ANeuralNetworksMemory creato solo con ANeuralNetworksExecution_setInputFromMemory() o ANeuralNetworksExecution_setOutputFromMemory() in base ai ruoli specificati nell'oggetto ANeuralNetworksMemoryDesc. Gli argomenti offset e length devono essere impostati su 0, per indicare che viene utilizzata l'intera memoria. Il client può anche impostare o estrarre esplicitamente i contenuti della memoria utilizzando ANeuralNetworksMemory_copy().

Puoi creare memorie opache con ruoli di dimensioni o rango non specificati. In questo caso, la creazione della memoria potrebbe non riuscire con lo stato ANEURALNETWORKS_OP_FAILED se non è supportata dal driver sottostante. Il client è invitato a implementare la logica di riserva allocando un buffer sufficientemente grande supportato da Ashmem o AHardwareBuffer in modalità BLOB.

Quando NNAPI non ha più bisogno di accedere all'oggetto di memoria opaco, libera l'istanza ANeuralNetworksMemory corrispondente:

ANeuralNetworksMemory_free(opaqueMem);

Misurare il rendimento

Puoi valutare le prestazioni della tua app misurando il tempo di esecuzione o tramite la profilazione.

Tempo di esecuzione

Se vuoi determinare il tempo di esecuzione totale tramite il runtime, puoi utilizzare l'API di esecuzione sincrona e misurare il tempo impiegato dalla chiamata. Quando vuoi determinare il tempo di esecuzione totale tramite un livello inferiore dello stack software, puoi utilizzare ANeuralNetworksExecution_setMeasureTiming e ANeuralNetworksExecution_getDuration per ottenere:

  • tempo di esecuzione su un acceleratore (non nel driver, che viene eseguito sul processore host).
  • tempo di esecuzione nel driver, incluso il tempo sull'acceleratore.

Il tempo di esecuzione nel driver esclude l'overhead, ad esempio quello del runtime stesso e dell'IPC necessario per la comunicazione del runtime con il driver.

Queste API misurano la durata tra gli eventi di invio e completamento del lavoro, anziché il tempo dedicato da un driver o un acceleratore all'esecuzione dell'inferenza, che potrebbe essere interrotto dal cambio di contesto.

Ad esempio, se l'inferenza 1 inizia, il driver interrompe il lavoro per eseguire l'inferenza 2, quindi riprende e completa l'inferenza 1, il tempo di esecuzione dell'inferenza 1 includerà il tempo in cui il lavoro è stato interrotto per eseguire l'inferenza 2.

Queste informazioni sui tempi possono essere utili per un deployment in produzione di un'applicazione per raccogliere dati di telemetria per l'utilizzo offline. Puoi utilizzare i dati di temporizzazione per modificare l'app e migliorarne le prestazioni.

Quando utilizzi questa funzionalità, tieni presente quanto segue:

  • La raccolta di informazioni sui tempi potrebbe comportare un costo in termini di prestazioni.
  • Solo un driver è in grado di calcolare il tempo trascorso al suo interno o sull'acceleratore, escluso il tempo trascorso nel runtime NNAPI e nell'IPC.
  • Puoi utilizzare queste API solo con un ANeuralNetworksExecution creato con ANeuralNetworksCompilation_createForDevices con numDevices = 1.
  • Non è necessario alcun driver per poter segnalare le informazioni di temporizzazione.

Profila la tua applicazione con Android Systrace

A partire da Android 10, NNAPI genera automaticamente eventi systrace che puoi utilizzare per profilare la tua applicazione.

Il codice sorgente NNAPI include un'utilità parse_systrace per elaborare gli eventi systrace generati dalla tua applicazione e generare una visualizzazione tabulare che mostra il tempo trascorso nelle diverse fasi del ciclo di vita del modello (creazione di un'istanza, preparazione, esecuzione della compilazione e terminazione) e nei diversi livelli delle applicazioni. I livelli in cui è suddivisa l'applicazione sono:

  • Application: il codice dell'applicazione principale
  • Runtime: runtime NNAPI
  • IPC: la comunicazione tra processi tra il runtime NNAPI e il codice del driver
  • Driver: il processo del driver dell'acceleratore.

Genera i dati di analisi della profilazione

Supponendo che tu abbia eseguito il checkout dell'albero dei sorgenti AOSP in $ANDROID_BUILD_TOP e che utilizzi l'esempio di classificazione delle immagini TFLite come applicazione di destinazione, puoi generare i dati di profilazione NNAPI con i seguenti passaggi:

  1. Avvia Systrace di Android con il seguente comando:
$ANDROID_BUILD_TOP/external/chromium-trace/systrace.py  -o trace.html -a org.tensorflow.lite.examples.classification nnapi hal freq sched idle load binder_driver

Il parametro -o trace.html indica che le tracce verranno scritte in trace.html. Quando esegui la profilazione della tua applicazione, dovrai sostituire org.tensorflow.lite.examples.classification con il nome del processo specificato nel manifest dell'app.

In questo modo, una delle tue console shell sarà occupata. Non eseguire il comando in background, poiché attende in modo interattivo la terminazione di un enter.

  1. Dopo aver avviato l'agente di raccolta systrace, avvia l'app ed esegui il test di benchmark.

Nel nostro caso, puoi avviare l'app Image Classification da Android Studio o direttamente dalla UI del tuo smartphone di test se l'app è già stata installata. Per generare alcuni dati NNAPI, devi configurare l'app in modo che utilizzi NNAPI selezionando NNAPI come dispositivo di destinazione nella finestra di dialogo di configurazione dell'app.

  1. Al termine del test, termina systrace premendo enter sul terminale della console attivo dal passaggio 1.

  2. Esegui l'utilità systrace_parser per generare statistiche cumulative:

$ANDROID_BUILD_TOP/frameworks/ml/nn/tools/systrace_parser/parse_systrace.py --total-times trace.html

Il parser accetta i seguenti parametri: - --total-times: mostra il tempo totale trascorso in un livello, incluso il tempo trascorso in attesa dell'esecuzione di una chiamata a un livello sottostante - --print-detail: stampa tutti gli eventi raccolti da systrace - --per-execution: stampa solo l'esecuzione e le relative sottofasi (come tempi per esecuzione) anziché le statistiche per tutte le fasi - --json: produce l'output in formato JSON

Di seguito è riportato un esempio di output:

===========================================================================================================================================
NNAPI timing summary (total time, ms wall-clock)                                                      Execution
                                                           ----------------------------------------------------
              Initialization   Preparation   Compilation           I/O       Compute      Results     Ex. total   Termination        Total
              --------------   -----------   -----------   -----------  ------------  -----------   -----------   -----------   ----------
Application              n/a         19.06       1789.25           n/a           n/a         6.70         21.37           n/a      1831.17*
Runtime                    -         18.60       1787.48          2.93         11.37         0.12         14.42          1.32      1821.81
IPC                     1.77             -       1781.36          0.02          8.86            -          8.88             -      1792.01
Driver                  1.04             -       1779.21           n/a           n/a          n/a          7.70             -      1787.95

Total                   1.77*        19.06*      1789.25*         2.93*        11.74*        6.70*        21.37*         1.32*     1831.17*
===========================================================================================================================================
* This total ignores missing (n/a) values and thus is not necessarily consistent with the rest of the numbers

Il parser potrebbe non riuscire se gli eventi raccolti non rappresentano una traccia completa dell'applicazione. In particolare, potrebbe non riuscire se nella traccia sono presenti eventi systrace generati per contrassegnare la fine di una sezione senza un evento di inizio della sezione associato. In genere, questo accade se alcuni eventi di una sessione di profilazione precedente vengono generati quando avvii l'agente di raccolta systrace. In questo caso, dovrai eseguire nuovamente la profilazione.

Aggiungi le statistiche per il codice dell'applicazione all'output di systrace_parser

L'applicazione parse_systrace si basa sulla funzionalità systrace integrata di Android. Puoi aggiungere tracce per operazioni specifiche nella tua app utilizzando l'API systrace (per Java, per applicazioni native) con nomi di eventi personalizzati.

Per associare gli eventi personalizzati alle fasi del ciclo di vita dell'applicazione, anteponi al nome dell'evento una delle seguenti stringhe:

  • [NN_LA_PI]: evento a livello di applicazione per l'inizializzazione
  • [NN_LA_PP]: evento a livello di applicazione per la preparazione
  • [NN_LA_PC]: evento a livello di applicazione per la compilazione
  • [NN_LA_PE]: evento a livello di applicazione per l'esecuzione

Ecco un esempio di come puoi modificare il codice di esempio della classificazione delle immagini TFLite aggiungendo una sezione runInferenceModel per la fase Execution e il livello Application contenente un'altra sezione preprocessBitmap che non verrà considerata nelle tracce NNAPI. La sezione runInferenceModel farà parte degli eventi systrace elaborati dall'analizzatore sintattico systrace NNAPI:

Kotlin

/** Runs inference and returns the classification results. */
fun recognizeImage(bitmap: Bitmap): List {
   // This section won’t appear in the NNAPI systrace analysis
   Trace.beginSection("preprocessBitmap")
   convertBitmapToByteBuffer(bitmap)
   Trace.endSection()

   // Run the inference call.
   // Add this method in to NNAPI systrace analysis.
   Trace.beginSection("[NN_LA_PE]runInferenceModel")
   long startTime = SystemClock.uptimeMillis()
   runInference()
   long endTime = SystemClock.uptimeMillis()
   Trace.endSection()
    ...
   return recognitions
}

Java

/** Runs inference and returns the classification results. */
public List recognizeImage(final Bitmap bitmap) {

 // This section won’t appear in the NNAPI systrace analysis
 Trace.beginSection("preprocessBitmap");
 convertBitmapToByteBuffer(bitmap);
 Trace.endSection();

 // Run the inference call.
 // Add this method in to NNAPI systrace analysis.
 Trace.beginSection("[NN_LA_PE]runInferenceModel");
 long startTime = SystemClock.uptimeMillis();
 runInference();
 long endTime = SystemClock.uptimeMillis();
 Trace.endSection();
  ...
 Trace.endSection();
 return recognitions;
}

Qualità del servizio

In Android 11 e versioni successive, NNAPI consente una migliore qualità del servizio (QoS) consentendo a un'applicazione di indicare le priorità relative dei suoi modelli, il tempo massimo previsto per preparare un determinato modello e il tempo massimo previsto per completare un determinato calcolo. Android 11 introduce anche ulteriori codici dei risultati NNAPI che consentono alle applicazioni di comprendere errori come le scadenze di esecuzione non rispettate.

Imposta la priorità di un workload

Per impostare la priorità di un workload NNAPI, chiama ANeuralNetworksCompilation_setPriority() prima di chiamare ANeuralNetworksCompilation_finish().

Imposta scadenze

Le applicazioni possono impostare scadenze sia per la compilazione che per l'inferenza del modello.

Scopri di più sugli operandi

La sezione seguente illustra argomenti avanzati sull'utilizzo degli operandi.

Tensori quantizzati

Un tensore quantizzato è un modo compatto per rappresentare un array n-dimensionale di valori in virgola mobile.

NNAPI supporta tensori quantizzati asimmetrici a 8 bit. Per questi tensori, il valore di ogni cella è rappresentato da un numero intero a 8 bit. Al tensore sono associati un valore di scala e un valore di punto zero. Questi vengono utilizzati per convertire gli interi a 8 bit nei valori in virgola mobile rappresentati.

La formula è:

(cellValue - zeroPoint) * scale

dove il valore zeroPoint è un numero intero a 32 bit e la scala è un valore in virgola mobile a 32 bit.

Rispetto ai tensori di valori in virgola mobile a 32 bit, i tensori quantizzati a 8 bit presentano due vantaggi:

  • L'applicazione è più piccola, poiché i pesi addestrati occupano un quarto delle dimensioni dei tensori a 32 bit.
  • I calcoli possono spesso essere eseguiti più velocemente. Ciò è dovuto alla minore quantità di dati che devono essere recuperati dalla memoria e all'efficienza dei processori, come i DSP, nell'eseguire calcoli con numeri interi.

Sebbene sia possibile convertire un modello in virgola mobile in uno quantizzato, la nostra esperienza ha dimostrato che si ottengono risultati migliori addestrando direttamente un modello quantizzato. In effetti, la rete neurale impara a compensare la maggiore granularità di ogni valore. Per ogni tensore quantizzato, i valori di scale e zeroPoint vengono determinati durante il processo di addestramento.

In NNAPI, i tipi di tensori quantizzati vengono definiti impostando il campo del tipo della struttura dei dati ANeuralNetworksOperandType su ANEURALNETWORKS_TENSOR_QUANT8_ASYMM. Inoltre, specifichi il valore scale e zeroPoint del tensore in quella struttura di dati.

Oltre ai tensori quantizzati asimmetrici a 8 bit, NNAPI supporta quanto segue:

Operandi facoltativi

Alcune operazioni, come ANEURALNETWORKS_LSH_PROJECTION, accettano operandi facoltativi. Per indicare nel modello che l'operando facoltativo è omesso, chiama la funzione ANeuralNetworksModel_setOperandValue(), passando NULL per il buffer e 0 per la lunghezza.

Se la decisione sulla presenza o meno dell'operando varia per ogni esecuzione, indichi che l'operando viene omesso utilizzando le funzioni ANeuralNetworksExecution_setInput() o ANeuralNetworksExecution_setOutput(), passando NULL per il buffer e 0 per la lunghezza.

Tensori di rango sconosciuto

Android 9 (livello API 28) ha introdotto operandi del modello di dimensioni sconosciute, ma con un ranking noto (il numero di dimensioni). Android 10 (livello API 29) ha introdotto tensori di rango sconosciuto, come mostrato in ANeuralNetworksOperandType.

Benchmark NNAPI

Il benchmark NNAPI è disponibile su AOSP in platform/test/mlts/benchmark (app di benchmark) e platform/test/mlts/models (modelli e set di dati).

Il benchmark valuta la latenza e l'accuratezza e confronta i driver con lo stesso lavoro eseguito utilizzando TensorFlow Lite sulla CPU, per gli stessi modelli e set di dati.

Per utilizzare il benchmark:

  1. Collega un dispositivo Android di destinazione al computer, apri una finestra del terminale e assicurati che il dispositivo sia raggiungibile tramite adb.

  2. Se sono collegati più dispositivi Android, esporta la variabile di ambiente del dispositivo di destinazione ANDROID_SERIAL.

  3. Vai alla directory di origine di primo livello di Android.

  4. Esegui questi comandi:

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

    Al termine di un'esecuzione del benchmark, i risultati verranno presentati come una pagina HTML passata a xdg-open.

Log NNAPI

NNAPI genera informazioni diagnostiche utili nei log di sistema. Per analizzare i log, utilizza l'utilità logcat.

Attiva il logging NNAPI dettagliato per fasi o componenti specifici impostando la proprietà debug.nn.vlog (utilizzando adb shell) sul seguente elenco di valori, separati da spazio, due punti o virgola:

  • model: creazione del modello
  • compilation: generazione del piano di esecuzione del modello e compilazione
  • execution: esecuzione del modello
  • cpuexe: esecuzione di operazioni utilizzando l'implementazione della CPU NNAPI
  • manager: estensioni NNAPI, interfacce disponibili e informazioni relative alle funzionalità
  • all o 1: tutti gli elementi precedenti

Ad esempio, per attivare il logging dettagliato completo, utilizza il comando adb shell setprop debug.nn.vlog all. Per disattivare il logging dettagliato, utilizza il comando adb shell setprop debug.nn.vlog '""'.

Una volta abilitato, il logging dettagliato genera voci di log a livello INFO con un tag impostato sul nome della fase o del componente.

Oltre ai messaggi controllati da debug.nn.vlog, i componenti dell'API NNAPI forniscono altre voci di log a vari livelli, ognuna delle quali utilizza un tag di log specifico.

Per ottenere un elenco di componenti, cerca nell'albero di origine utilizzando la seguente espressione:

grep -R 'define LOG_TAG' | awk -F '"' '{print $2}' | sort -u | egrep -v "Sample|FileTag|test"

Al momento questa espressione restituisce i seguenti tag:

  • BurstBuilder
  • Richiamate
  • CompilationBuilder
  • CpuExecutor
  • ExecutionBuilder
  • ExecutionBurstController
  • ExecutionBurstServer
  • ExecutionPlan
  • FibonacciDriver
  • GraphDump
  • IndexedShapeWrapper
  • IonWatcher
  • Gestore
  • Memoria
  • MemoryUtils
  • MetaModel
  • ModelArgumentInfo
  • ModelBuilder
  • NeuralNetworks
  • OperationResolver
  • Operazioni
  • OperationsUtils
  • PackageInfo
  • TokenHasher
  • TypeManager
  • Utils
  • ValidateHal
  • VersionedInterfaces

Per controllare il livello dei messaggi di log mostrati da logcat, utilizza la variabile di ambiente ANDROID_LOG_TAGS.

Per visualizzare l'insieme completo di messaggi di log NNAPI e disattivare tutti gli altri, imposta ANDROID_LOG_TAGS su quanto segue:

BurstBuilder:V Callbacks:V CompilationBuilder:V CpuExecutor:V ExecutionBuilder:V ExecutionBurstController:V ExecutionBurstServer:V ExecutionPlan:V FibonacciDriver:V GraphDump:V IndexedShapeWrapper:V IonWatcher:V Manager:V MemoryUtils:V Memory:V MetaModel:V ModelArgumentInfo:V ModelBuilder:V NeuralNetworks:V OperationResolver:V OperationsUtils:V Operations:V PackageInfo:V TokenHasher:V TypeManager:V Utils:V ValidateHal:V VersionedInterfaces:V *:S.

Puoi impostare ANDROID_LOG_TAGS utilizzando il seguente comando:

export ANDROID_LOG_TAGS=$(grep -R 'define LOG_TAG' | awk -F '"' '{ print $2 ":V" }' | sort -u | egrep -v "Sample|FileTag|test" | xargs echo -n; echo ' *:S')

Tieni presente che si tratta solo di un filtro che si applica a logcat. Devi comunque impostare la proprietà debug.nn.vlog su all per generare informazioni di log dettagliate.