Cette page a été traduite par l'API Cloud Translation.

Reconnaître des fleurs avec TensorFlow Lite sur iOS

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 $\\uf339$ $\\uf33b$ $\\uf337$ !

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.

Fichier de pod

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:

ModelDataHandler.swift

/// 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 :

ModelDataHandler.swift

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.

ModelDataHandler.swift

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.