1. Introduction
TensorFlow est un framework de machine learning polyvalent. TensorFlow peut être utilisé partout, de l'entraînement de modèles volumineux sur des clusters dans le cloud à l'exécution de modèles en local sur un système intégré comme votre téléphone.
Cet atelier de programmation utilise TensorFlow Lite pour exécuter un modèle de reconnaissance d'image sur un appareil iOS.
Points abordés
- Comment optimiser votre modèle à l'aide du convertisseur TFLite.
- Exécuter l'application dans une application iOS prédéfinie à l'aide de l'interpréteur TFLite
Objectif de cet atelier
Application d'appareil photo simple qui exécute un programme de reconnaissance d'image TensorFlow pour identifier des fleurs.
Prérequis
Si vous suivez cet atelier de programmation sur votre propre matériel, assurez-vous que les éléments suivants sont installés:
- Xcode 10 ou version ultérieure
- CocoaPods 1.8.0 ou version ultérieure
Licence: Sans frais
2. Entraîner un programme de reconnaissance de fleurs à l'aide de Colab
Cet atelier de programmation utilisera Colaboratory et Xcode.
Ouvrez Colab, qui utilise TensorFlow Lite Model Maker pour entraîner un classificateur à reconnaître des fleurs à l'aide de l'apprentissage par transfert, puis exportez un modèle TFLite à utiliser dans l'application mobile.
3. Configurer le répertoire de travail
Cloner le dépôt Git
La commande suivante clone le dépôt Git contenant les fichiers nécessaires pour cet atelier de programmation:
git clone https://github.com/tensorflow/examples.git
Maintenant, cd
dans la racine du projet Xcode du clone que vous venez de créer. C'est là que vous allez travailler pour le reste de cet atelier de programmation:
cd examples/lite/examples/image_classification/ios
4. Configurer l'application iOS
Installer des dépendances
À l'aide de CocoaPods, installez les dépendances de l'application iOS (y compris TensorFlow Lite). Une fois la commande d'installation terminée, ouvrez ImageClassification.xcworkspace
pour ouvrir le projet dans Xcode.
pod install --repo-update open ImageClassification.xcworkspace
5. Tester l'application
Pour utiliser l'appareil photo, l'application doit être exécutée sur un appareil réel, car le simulateur iOS n'a pas accès à l'appareil photo de votre Mac. Pour compiler sur un appareil iOS, vous devez être inscrit au programme Apple Developer ou avoir accès à un appareil fourni par quelqu'un d'autre.
Si vous souhaitez exécuter cet atelier de programmation dans le simulateur, vous devrez copier des images dans le presse-papiers depuis Safari, directement dans le simulateur. Voici les étapes à suivre pour traiter une image dans le simulateur:
- Créez l'application sur la cible du simulateur de votre choix.
- Dans le simulateur iOS, appuyez sur Cmd+Maj+H pour réduire l'application.
- Appuyez sur Safari en bas de l'écran d'accueil et recherchez une image.
- Dans les résultats de recherche d'images Google, appuyez sur un résultat, puis appuyez de manière prolongée sur l'image. Dans la boîte de dialogue qui s'affiche, sélectionnez "Copier".
- Revenez à l'application TFL Classify. L'image copiée devrait s'afficher automatiquement avec les résultats de l'inférence. Si ce n'est pas le cas, assurez-vous d'avoir copié les données de l'image elles-mêmes et non l'URL de l'image.
Tester le build et installer l'application
Avant d'apporter des modifications à l'application, exécutez la version fournie avec le dépôt. Sélectionnez votre appareil iOS dans le menu déroulant en haut à gauche:
Appuyez ensuite sur Cmd+R ou appuyez sur le bouton de lecture dans Xcode pour créer l'application sur votre appareil. Une fois installée sur votre appareil, l'application devrait se lancer automatiquement.
Cette version de l'application utilise la version standard de MobileNet, pré-entraînée sur les 1 000 catégories ImageNet. Voici un exemple :
6. Exécuter l'application personnalisée
La configuration par défaut de l'application permet de classer les images dans l'une des 1 000 classes ImageNet à l'aide de la version standard de MobileNet.
Modifions maintenant l'application afin qu'elle utilise notre modèle réentraîné pour nos catégories d'images personnalisées entraînées dans Colab.
7. Convertir l'application pour exécuter votre modèle
Ajouter les fichiers de modèle au projet
Les ressources de modèle du projet se trouvent dans ImageClassification > Model
, dans le navigateur de projets Xcode. Pour les remplacer, supprimez d'abord les deux fichiers existants dans le groupe Model
. Lorsque vous y êtes invité, sélectionnez "Placer dans la corbeille" :
Ensuite, faites glisser les fichiers model.tflite
et labels.txt
que vous avez téléchargés depuis Colab vers le groupe de modèles. Lorsque vous y êtes invité, assurez-vous que les options Copy items if needed
et Add to targets
sont toutes les deux sélectionnées.
Modifier le code de l'application
Pour que notre application fonctionne, nous devons mettre à jour le chemin de la logique de chargement du modèle afin qu'il pointe vers le nouveau modèle que nous avons ajouté.
Ouvrez ModelDataHandler.swift (chemin du navigateur Xcode: ImageClassification -> ModelDataHandler -> ModelDataHandler.swift) et remplacez la ligne 36 par
// before static let modelInfo: FileInfo = (name: "mobilenet_quant_v1_224", extension: "tflite") // after static let modelInfo: FileInfo = (name: "model", extension: "tflite")
Veillez à enregistrer toutes les modifications.
8. Exécuter l'application personnalisée
Appuyez sur Cmd+B ou appuyez sur le bouton de lecture dans Xcode pour créer l'application sur votre appareil. Une fois l'application lancée, elle doit se présenter comme suit:
Vous pouvez faire une capture d'écran en appuyant de manière prolongée sur les boutons Marche/Arrêt et volume+.
Essayez maintenant de rechercher des fleurs sur le Web, dirigez l'appareil photo vers l'écran de l'ordinateur et vérifiez si ces images sont classées correctement.
Ou demandez à un ami de vous prendre en photo et de découvrir quel genre de TensorFlow vous êtes
!
9. Fonctionnement
Maintenant que l'application est en cours d'exécution, examinons le code spécifique à TensorFlow Lite.
TensorFlowLiteSwift
Cette application utilise la bibliothèque TensorFlowLite Swift via CocoaPods. La bibliothèque Swift est un wrapper léger sur l'API TFLite C, qui est elle-même un wrapper de la bibliothèque C++ TFLite.
Les lignes suivantes du fichier Podfile du module extraient la dernière version du dépôt global des spécifications CocoaPods du pod dans le projet.
target 'ImageClassification' do
use_frameworks!
# Pods for ImageClassification
pod 'TensorFlowLiteSwift'
end
Utiliser l'API TensorFlow Lite Swift
Le code interagissant avec TensorFlow Lite est contenu dans ModelDataHandler.swift.
Configuration
Le premier bloc qui nous intéresse est l'initialiseur de 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)
}
Quelques lignes doivent être abordées plus en détail.
La ligne suivante crée l'interpréteur TFLite :
interpreter = try Interpreter(modelPath: modelPath, options: options)
L'interpréteur est chargé de transmettre les entrées de données brutes via le graphe TensorFlow. Nous transmettons à l'interpréteur le chemin d'accès à notre modèle sur le disque, puis l'interpréteur le charge en tant que FlatBufferModel.
La dernière ligne charge la liste des étiquettes:
loadLabels(fileInfo: labelsFileInfo)
Il s'agit simplement de charger des chaînes à partir d'un fichier texte dans la mémoire.
Exécuter le modèle
Le deuxième bloc présentant un certain intérêt est la méthode runModel
. Il accepte un CVPixelBuffer
en entrée, exécute l'interpréteur et renvoie le texte à imprimer dans l'application.
try interpreter.copy(rgbData, toInputAt: 0)
// ...
try interpreter.invoke()
// ...
outputTensor = try interpreter.output(at: 0)
10. Et maintenant ?
Voici quelques liens pour en savoir plus:
- Pour en savoir plus sur TFLite, consultez la documentation sur tensorflow.org et le dépôt source.
- Essayez d'autres modèles pré-entraînés TFLite, tels qu'un détecteur vocal de mots clés et une version intégrée des réponses suggérées.
- Pour en savoir plus sur TensorFlow en général, consultez notre documentation de démarrage.