ml — Machine Learning

Il modulo ml contiene funzionalità per il caricamento e l’esecuzione di modelli TensorFlow Lite su OpenMV Cam. Il modulo espone un’unica classe rivolta all’utente, ml.Model, che incapsula la classe C Model sottostante aggiungendo comodità sul lato Python (caricamento automatico delle etichette e conversione automatica da immagine a tensore).

Sottomoduli

class Model – Contenitore del modello

class ml.Model(path: str, *, postprocess: object = None) → Model

Carica un modello TensorFlow Lite da path in memoria e lo prepara per l’inferenza. path può essere un file sul filesystem oppure il nome di un modello incorporato nell’immagine del firmware.

postprocess è un callable opzionale di post-elaborazione invocato da Model.predict dopo l’inferenza. Riceve (model, inputs, outputs) e può restituire qualsiasi valore (ad es. un elenco di bounding box). Quando viene fornito, il post-elaboratore riceve i tensori di output grezzi del modello (non dequantizzati) per ragioni di prestazioni.

Alla costruzione, il wrapper tenta inoltre di caricare un file .txt con lo stesso nome base di path; se trovato, ogni riga viene caricata in Model.labels. Altrimenti Model.labels è None.

predict(inputs: list, *, callback: object = None) → list

Esegue l’inferenza sul modello e restituisce i tensori di output.

inputs è un elenco con una voce per ciascun tensore di input del modello. Ogni voce può essere:

  • Un ndarray la cui forma corrisponde alla voce corrispondente in Model.input_shape. I valori vengono quantizzati utilizzando la scala e lo zero point del tensore di input (gli input float32 vengono trasferiti invariati).

  • Un oggetto image.Image. Il wrapper lo incapsula automaticamente in un oggetto ml.preprocessing.Normalization per convertirlo nel tensore previsto.

  • Un callable. Verrà invocato con (bytearray, shape, dtype) e si prevede che riempia il bytearray con i dati del tensore di input.

callback è un callable di post-elaborazione opzionale per singola chiamata. Quando fornito, sostituisce il postprocess impostato nel costruttore solo per questa chiamata. La callback riceve (model, inputs, outputs) e il suo valore di ritorno viene restituito da predict.

Restituisce un elenco di output ndarray, uno per ciascun tensore di output del modello. Se nessun post-elaboratore è attivo, gli output vengono dequantizzati in float32; se un post-elaboratore è attivo, gli vengono invece passati i tensori di output grezzi (utilizzando il dtype nativo di ciascun tensore).

len: int

La dimensione del modello caricato in byte.

ram: int

La quantità di RAM utilizzata dalla tensor arena del modello, in byte.

input_shape: list[tuple[int, ...]]

Un elenco di tuple che indicano la forma di ciascun tensore di input.

input_dtype: list[str]

Un elenco di stringhe di un singolo carattere che indicano il dtype di ciascun tensore di input: 'b' (int8), 'B' (uint8), 'h' (int16), 'H' (uint16), 'f' (float32).

input_scale: list[float]

Un elenco di float che indicano la scala di quantizzazione di ciascun tensore di input.

input_zero_point: list[int]

Un elenco di interi che indicano lo zero point di quantizzazione di ciascun tensore di input.

output_shape: list[tuple[int, ...]]

Un elenco di tuple che indicano la forma di ciascun tensore di output.

output_dtype: list[str]

Un elenco di stringhe di un singolo carattere che indicano il dtype di ciascun tensore di output: 'b' (int8), 'B' (uint8), 'h' (int16), 'H' (uint16), 'f' (float32).

output_scale: list[float]

Un elenco di float che indicano la scala di quantizzazione di ciascun tensore di output.

output_zero_point: list[int]

Un elenco di interi che indicano lo zero point di quantizzazione di ciascun tensore di output.

postprocess: object

Il callable di post-elaborazione fornito al costruttore, oppure None.

labels: list[str]

Elenco di stringhe di etichetta caricate dal file .txt affiancato al modello, oppure None se tale file non esiste.