1. Introduzione
TensorFlow è un framework di machine learning multiuso. TensorFlow può essere utilizzato ovunque, dall'addestramento di modelli enormi in cluster nel cloud all'esecuzione locale di modelli su un sistema incorporato come il tuo smartphone.
Questo codelab utilizza TensorFlow Lite per eseguire un modello di riconoscimento delle immagini su un dispositivo iOS.
Cosa imparerai a fare
- Come ottimizzare il modello utilizzando il convertitore TFLite.
- Come eseguirlo in un'app iOS predefinita utilizzando l'interprete TFLite.
Cosa creerai
Una semplice app per fotocamera che esegue un programma di riconoscimento delle immagini TensorFlow per identificare i fiori.
Prerequisiti
Se esegui questo codelab su un tuo hardware, assicurati di aver installato quanto segue:
- Xcode 10 o superiore
- CocoaPods 1.8.0 o versioni successive
Licenza: senza costi
2. Addestra un riconoscimento dei fiori con Colab
Questo codelab userà Colaboratory e Xcode.
Apri Colab che utilizza TensorFlow Lite Model Maker per addestrare un classificatore in modo che riconosca i fiori utilizzando il Transfer Learning ed esporta un modello TFLite da utilizzare nell'app mobile.
3. Configura la directory di lavoro
clona il repository Git
Il seguente comando clonerà il repository Git contenente i file richiesti per questo codelab:
git clone https://github.com/tensorflow/examples.git
Ora cd nella radice del progetto Xcode del clone appena creato. Lavorerai qui per il resto di questo codelab:
cd examples/lite/examples/image_classification/ios
4. Configura l'app per iOS
Installa le dipendenze
Con CocoaPods, installa le dipendenze dell'app per iOS (incluso TensorFlow Lite). Al termine del comando di installazione, apri ImageClassification.xcworkspace per aprire il progetto in Xcode.
pod install --repo-update open ImageClassification.xcworkspace
5. Testare l'esecuzione dell'app
Per utilizzare la fotocamera, l'app deve essere eseguita su un dispositivo reale, poiché il simulatore iOS non ha accesso alla fotocamera del Mac. Per creare su un dispositivo iOS, devi essere iscritto all'Apple Developer Program o avere accesso a un dispositivo di cui qualcun altro ha eseguito il provisioning per te.
Se vuoi eseguire questo codelab nel simulatore, dovrai copiare le immagini da Safari nel simulatore stesso. Di seguito sono riportati i passaggi per elaborare un'immagine nel simulatore:
- Crea l'app per il simulatore di destinazione che preferisci.
- Nel simulatore iOS, premi Cmd+Maiusc+H per ridurre a icona l'app.
- Tocca Safari nella parte inferiore della schermata Home e cerca un'immagine.
- Nei risultati di ricerca di Google Immagini, tocca un risultato e premi a lungo l'immagine. Nella finestra di dialogo visualizzata, seleziona "Copia".
- Torna all'app TFL Classify. L'immagine copiata dovrebbe essere visualizzata automaticamente insieme ai risultati dell'inferenza. In caso contrario, assicurati di aver copiato i dati dell'immagine e non l'URL dell'immagine.
Testa la build e installa l'app
Prima di apportare modifiche all'app, eseguiamo la versione fornita con il repository. Seleziona il tuo dispositivo iOS dal menu a discesa in alto a sinistra:
Poi premi Cmd+R o premi il pulsante Riproduci 
in Xcode per creare l'app sul tuo dispositivo. L'app dovrebbe avviarsi automaticamente una volta installata sul dispositivo.
Questa versione dell'app utilizza MobileNet standard, preaddestrato sulle 1000 categorie ImageNet. Il sito dovrebbe avere il seguente aspetto:
6. Esegui l'app personalizzata
La configurazione predefinita dell'app classifica le immagini in una delle 1000 classi ImageNet, utilizzando lo standard MobileNet.
Ora modifichiamo l'app in modo che utilizzi il nostro modello riaddestrato per le nostre categorie di immagini personalizzate addestrate in Colab.
7. Converti l'app per eseguire il modello
Aggiungi i file del tuo modello al progetto
Le risorse del modello del progetto si trovano in ImageClassification > Model nel navigatore dei progetti Xcode. Per sostituirli, elimina prima i due file esistenti nel gruppo Model. Quando richiesto, seleziona "Sposta nel cestino":
Quindi, trascina i file model.tflite e labels.txt che hai scaricato da Colab nel gruppo di modelli. Quando richiesto, assicurati che Copy items if needed e Add to targets siano entrambi selezionati.
Modificare il codice dell'app
Per far funzionare la nostra app, dobbiamo aggiornare il percorso della logica di caricamento del modello in modo che punti al nuovo modello che abbiamo aggiunto.
Apri ModelDataHandler.swift (percorso Xcode navigator: ImageClassification -> ModelDataGestori -> ModelDataGestori.swift) e cambia la ModelDataHandler.swift in
// before static let modelInfo: FileInfo = (name: "mobilenet_quant_v1_224", extension: "tflite") // after static let modelInfo: FileInfo = (name: "model", extension: "tflite")
Assicurati di salvare tutte le modifiche.
8. Esegui l'app personalizzata
Premi Cmd+B o premi il pulsante Riproduci in Xcode per creare l'app sul tuo dispositivo. Una volta avviata, l'app dovrebbe avere un aspetto simile al seguente:
Per fare uno screenshot, puoi tenere premuti contemporaneamente il tasto di accensione e il tasto Alza il volume.
Ora prova a cercare dei fiori sul web, inquadra con la fotocamera lo schermo del computer e controlla se le foto sono classificate correttamente.
Oppure chiedi a un amico di scattarti una foto per scoprire che tipo di TensorFlower sei 
!
9. Come funziona?
Ora che l'app è in esecuzione, vediamo il codice specifico di TensorFlow Lite.
TensorFlowLiteSwift
Questa app usa la libreria Swift TensorFlowLite tramite CocoaPods. La libreria Swift è un wrapper sottile sull'API TFLite C, che a sua volta è un wrapper della libreria TFLite C++.
Le seguenti righe nel file Podfile del modulo estrae nel progetto la versione più recente del repository globale delle specifiche di CocoaPods.
target 'ImageClassification' do
use_frameworks!
# Pods for ImageClassification
pod 'TensorFlowLiteSwift'
end
Utilizzo dell'API TensorFlow Lite Swift
Il codice che interagisce con TensorFlow Lite è tutto contenuto in ModelDataHandler.swift.
Configurazione
Il primo blocco di interesse è l'inizializzatore di ModelDataHandler:
/// A failable initializer for `ModelDataHandler`. A new instance is created if the model and
/// labels files are successfully loaded from the app's main bundle. Default `threadCount` is 1.
init?(modelFileInfo: FileInfo, labelsFileInfo: FileInfo, threadCount: Int = 1) {
let modelFilename = modelFileInfo.name
// Construct the path to the model file.
guard let modelPath = Bundle.main.path(
forResource: modelFilename,
ofType: modelFileInfo.extension
) else {
print("Failed to load the model file with name: \(modelFilename).")
return nil
}
// Specify the options for the `Interpreter`.
self.threadCount = threadCount
var options = InterpreterOptions()
options.threadCount = threadCount
do {
// Create the `Interpreter`.
interpreter = try Interpreter(modelPath: modelPath, options: options)
// Allocate memory for the model's input `Tensor`s.
try interpreter.allocateTensors()
} catch let error {
print("Failed to create the interpreter with error: \(error.localizedDescription)")
return nil
}
// Load the classes listed in the labels file.
loadLabels(fileInfo: labelsFileInfo)
}
Ci sono alcune righe che dovrebbero essere discusse più in dettaglio.
La seguente riga crea l'interprete TFLite:
interpreter = try Interpreter(modelPath: modelPath, options: options)
L'interprete è responsabile del passaggio degli input di dati non elaborati attraverso il grafico TensorFlow. Passiamo all'interprete il percorso del nostro modello su disco e l'interprete lo carica quindi come FlatBufferModel.
L'ultima riga carica l'elenco delle etichette:
loadLabels(fileInfo: labelsFileInfo)
Tutto ciò che fa è caricare stringhe da un file di testo in memoria.
Esegui il modello
Il secondo blocco di interesse è il metodo runModel. Richiede un CVPixelBuffer come input, esegue l'interprete e restituisce il testo da stampare nell'app.
try interpreter.copy(rgbData, toInputAt: 0)
// ...
try interpreter.invoke()
// ...
outputTensor = try interpreter.output(at: 0)
10. Passaggi successivi
Ecco alcuni link per saperne di più:
- Scopri di più su TFLite dalla documentazione su tensorflow.org e dal repository di codice sorgente.
- Prova altri modelli preaddestrati TFLite, tra cui un rilevatore di hotword vocale e una versione on-device della risposta intelligente.
- Scopri di più su TensorFlow in generale nella nostra documentazione introduttiva.