Come abbiamo mostrato nelle lezioni precedenti, ML Kit mette a disposizione degli sviluppatori una vasta gamma di modelli pre-addestrati per svolgere una serie di task comuni di intelligenza artificiale direttamente sulle piattaforme mobile. Questi modelli sono stati addestrati su grandi set di dati e offrono funzionalità di alto livello. Senza la necessità di dover sviluppare e addestrare i modelli da zero.
Un aspetto molto interessante di MLKit è la possibilità di addestrare da zero dei propri modelli. In modo da permettere alla propria applicazione di svolgere delle attività che si discostano da quelle più "comuni".
Comprensione dei modelli di ML Kit
Un modello di machine learning è essenzialmente un'astrazione matematica di un fenomeno o di un processo che un algoritmo di machine learning apprende dai dati. Questo modello è in grado di fare previsioni o prendere decisioni senza essere esplicitamente programmato per compiere specifiche azioni. In pratica, un modello di machine learning è un insieme di regole matematiche e statistiche che identificano determinati pattern nei dati.
I modelli standard di ML Kit, come quelli di molti altri framework di machine learning, passano attraverso un processo di addestramento iniziale. Durante questa fase, il modello viene esposto a un gran numero di esempi in cui sono presenti le caratteristiche di input (come immagini, testo o dati numerici) e i risultati desiderati. Il modello impara a riconoscere i pattern nei dati e a regolare i suoi parametri interni per minimizzare gli errori tra le previsioni e i risultati attesi.
Dopo l'addestramento il modello viene validato e testato per assicurare che sia in grado di generalizzare su nuovi dati. Durante la fase di validazione, il modello viene valutato su un insieme di dati di validazione che non sono stati utilizzati durante l'addestramento. Mentre durante la fase di test viene testato su un insieme di dati di test indipendente per valutare le sue prestazioni finali.
Personalizzazione dei modelli in ML Kit
Nonostante l'ampia disponibilità dei modelli pre-addestrati, potrebbe essere necessario personalizzarli per adattarli alle esigenze specifiche dell'applicazione. ML Kit offre diverse opzioni per la personalizzazione dei modelli. Compreso il trasferimento di apprendimento e la creazione di modelli personalizzati da zero. Questo consente agli sviluppatori di modificare e adattare i modelli esistenti per ottenere prestazioni migliori o di creare completamente nuovi modelli per task unici.
In poche parole, se i modelli predefiniti di ML Kit non soddisfano le nostre esigenze, possiamo pensare di utilizzare un modello TensorFlow Lite personalizzato con ML Kit. I modelli che creeremo con esso potranno essere salvati utilizzando Firebase o all'interno della nostra stessa applicazione. La differenza tra i due approcci risiede nel fatto che se ospitiamo il modello in Firebase, ML Kit aggiornerà automaticamente ai nostri utenti la versione più recente del modello. In caso contrario dovremmo essere noi stessi ad aggiornare l'applicazione tramite lo store di riferimento (Google Play, App Store, ect. etc.).
Riconoscere pacchetti di patatine
Il riconoscimento di immagini è una delle applicazioni più comuni e utili dell'intelligenza artificiale. In questo paragrafo vedremo come addestrare un modello di riconoscimento di immagini utilizzando TensorFlow Lite. Ciò avverrà utilizzando l'architettura MobileNet_V1, per distinguere pacchetti di patatine di marche diverse. Il nostro obiettivo sarà quello di addestrare un modello che possa identificare correttamente la marca del pacchetto dalle immagini. Chiaramente per poter affrontare questo problema avremo bisogno di:
- una raccolta di immagini contenente pacchetti di diverse marche di patatine.
- Etichettare correttamente ogni immagine con la marca corrispondente.
Partiamo dal dataset
Supponiamo di avere un dataset di questo tipo (ma chiaramente possiamo utilizzare qualunque altro tipo di dataset di immagini). Per poter addestrare il nostro modello con il dataset sopra citato, useremo il linguaggio di programmazione Python con TensorFlow Lite. Per ragioni didattiche vedremo il codice che si occuperà di eseguire il training del modello. Chiaramente non andremo troppo nel dettaglio delle dinamiche dell'Intelligenza artificiale, proprio perchè ci sono delle guide ad hoc sull'argomento che sono sicuramente più esaustive. Quindi, in Python, scriviamo:
import tensorflow as tf
from tensorflow.keras.applications import MobileNet
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Model
# Carichiamo il modello MobileNetV1 pre-addestrato
base_model = MobileNet(weights='imagenet', include_top=False)
# Aggiungiamo un layer di Global Average Pooling e un layer completamente connesso
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(num_classes, activation='softmax')(x)
# Definiamo il modello finale
model = Model(inputs=base_model.input, outputs=predictions)
for layer in base_model.layers:
layer.trainable = False
# Compiliamo il modello
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
# Addestriamo il modello
model.fit(train_images, train_labels, epochs=epochs, batch_size=batch_size, validation_data=(val_images, val_labels))
# Infine, salviamo il modello
model.save('model_mobilenet.h5')Analizziamo il codice
Il codice proposto implementa un classificatore di immagini utilizzando il modello MobileNet_V1 pre-addestrato su ImageNet come base e aggiungendo strati aggiuntivi per adattarlo al problema specifico di classificazione delle immagini delle diverse marche di pacchetti di patatine.
Viene caricato il modello MobileNetV1 pre-addestrato su ImageNet utilizzando MobileNet dall'API di applicazioni Keras. Il parametro include_top=False indica che si desidera escludere i layer completamente connessi presenti alla fine del modello pre-addestrato, in quanto verranno aggiunti strati personalizzati. Infine, il modello addestrato viene salvato in un file con il formato H5 per un utilizzo futuro senza la necessità di ripetere l'addestramento.
Caricamento del modello in Android utilizzando TensorFlow Lite
Nel codice Android che abbiamo scritto in basso andremo a caricare il nostro modello TensorFlow Lite da un file ed eseguiremo l'inferenza grazie ad esso.
Una cosa importante da evidenziare è che nel flusso dell'addestramento del modello lo abbiamo salvato in formato H5 con l'estensione .h5. Quindi, per utilizzare il modello salvato in formato H5 su Android dovremmo prima convertirlo in formato TensorFlow Lite (TFLite) che è più leggero e ottimizzato per l'esecuzione su dispositivi mobile. La funzione Python demandata a questo scopo è la seguente:
import tensorflow as tf
model = tf.keras.models.load_model('model_mobilenet.h5')
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open('model_mobilenet.tflite', 'wb') as f:
f.write(tflite_model)Il codice Android
Adesso possiamo scrivere il nostro codice Android:
import org.tensorflow.lite.Interpreter;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
private MappedByteBuffer loadModelFile() throws IOException {
FileInputStream inputStream = new FileInputStream("model_mobilenet.tflite");
FileChannel fileChannel = inputStream.getChannel();
long startOffset = 0;
long declaredLength = fileChannel.size();
return fileChannel.map(FileChannel.MapMode.READ_ONLY, startOffset, declaredLength);
}
private void runInference() {
try {
Interpreter tflite = new Interpreter(loadModelFile());
} catch (IOException e) {
e.printStackTrace();
}
}La funzione loadModelFile() è una funzione privata che legge il file del modello TensorFlow Lite dal disco e restituisce un oggetto MappedByteBuffer contenente i dati del modello. Questo oggetto viene utilizzato per caricare il modello in memoria.
runInference(), invece, è una funzione privata che carica il modello TensorFlow Lite utilizzando l'oggetto Interpreter di TensorFlow Lite, creato con il metodo loadModelFile(). Una volta caricato il modello, è possibile eseguire l'inferenza utilizzando questo oggetto Interpreter. L'eccezione IOException viene gestita nel caso in cui si verifichi un errore durante il caricamento del modello dal file. In questo caso, viene stampato lo stack trace dell'errore.
Conclusioni: modelli personalizzati con ML Kit
In conclusione, abbiamo esplorato il processo di addestramento di un modello di riconoscimento delle immagini utilizzando TensorFlow Lite con l'architettura MobileNet_V1. Dopo aver preparato i dati e addestrato il modello in Python, abbiamo visto come convertirlo in formato TensorFlow Lite per l'utilizzo su dispositivi mobili Android.Il processo di addestramento e conversione del modello è stato seguito dall'integrazione nell'applicazione Android utilizzando le API di TensorFlow Lite. Consentendo all'applicazione di eseguire l'inferenza sul dispositivo mobile.
