Dans le monde récent du développement technologique et de l'apprentissage automatique, il ne se limite plus au micro-cloud mais dans les appareils mobiles. Comme nous le savons, Tensorflow Lite et Pytorch Mobile sont deux des outils les plus disponibles dans le commerce pour déployer des modèles directement sur les téléphones et les tablettes. Tensorflow Lite et Pytorch Mobile, tous deux, sont développés pour fonctionner sur Mobile, mais ils sont distincts dans leurs avantages et leurs inconvénients. Ici, dans cet article, nous devons savoir ce qu'est Tensorflow Lite, ce qu'est Pytorch Mobile, leurs applications et leurs différences entre les deux.

Résultats d'apprentissage

• Présentation de l'apprentissage automatique de l'appareil et pourquoi il est bénéfique plut?t que les systèmes basés sur le cloud.
• Renseignez-vous sur Tensorflow Lite et Pytorch Mobile utilisés pour le déploiement d'applications mobiles.
• Comment convertir des modèles formés pour le déploiement à l'aide de Tensorflow Lite et Pytorch Mobile.
• Comparez les performances, la facilité d'utilisation et la compatibilité des plates-formes de Tensorflow Lite et Pytorch Mobile.
• Implémentez des exemples réels d'apprentissage automatique sur les appareils à l'aide de Tensorflow Lite et Pytorch Mobile.

Cet article a été publié dans le cadre du Blogathon de la science des données.

Table des matières

• Qu'est-ce que l'apprentissage automatique sur les appareils?
• Exploration de TensorFlow Lite
• Implémentation mobile Pytorch
• Comparaison des performances: Tensorflow Lite vs Pytorch Mobile
• Facilité d'utilisation et expérience des développeurs
• Plates-formes prises en charge et compatibilité des appareils
• Conversion du modèle: de la formation au déploiement
• Des cas d'utilisation pour TensorFlow Lite et Pytorch Mobile
• Implémentation de TensorFlow Lite
• Implémentation mobile Pytorch
• Conclusion
• Questions fréquemment posées

Qu'est-ce que l'apprentissage automatique sur les appareils?

Nous pouvons effectuer l'IA sur les appareils mobiles, y compris le téléphone intelligent, la tablette ou tout autre appareil en utilisant l'apprentissage automatique de l'appareil. Nous n'avons pas besoin de compter sur les services de nuages. Il s'agit de la réponse rapide, de la sécurité des informations sensibles et de l'application peut s'exécuter avec ou sans connectivité Internet qui sont très vitales dans diverses applications; Reconnaissance d'images en temps réel, traduction automatique et réalité augmentée.

Exploration de TensorFlow Lite

TensorFlow Lite est la version Tensorflow qui est souvent utilisée sur des appareils avec des capacités restreintes. Il fonctionne et est compatible avec d'autres systèmes d'exploitation tels que l'Android et l'iPhone. Il se concentre principalement dans la fourniture de latence et de l'exécution haute performance. Quant à TensorFlow Lite, il existe un optimiseur de modèle qui aide à appliquer certaines méthodes, par exemple, la quantification aux modèles. Cela rend les modèles plus rapides et plus petits pour le déploiement mobile qui est impératif dans cette pratique pour améliorer l'efficacité.

Caractéristiques de TensorFlow Lite

Vous trouverez ci-dessous quelques caractéristiques les plus importantes de TensorFlow Lite:

• Petite taille binaire : les binaires Tensorflow Lite peuvent être de très petite taille. Il peut être aussi petit que 300 Ko.
• Accélération matérielle : TFLITE prend en charge GPU et d'autres accélérateurs matériels via des délégués, tels que le NNAPI d'Android et CoreMl d'IOS.
• Quantification du modèle : TFLITE propose de nombreuses méthodes de quantification différentes pour optimiser les performances et réduire la taille du modèle sans sacrifier trop de précision.

Implémentation mobile Pytorch

Pytorch Mobile est l'extension mobile de Pytorch. Il est généralement connu pour sa flexibilité dans la recherche et la production. Pytorch Mobile facilite la prise d'un modèle formé à partir d'un environnement de bureau et le déployez sur les appareils mobiles sans trop de modification. Il se concentre davantage sur la facilité d'utilisation du développeur en prenant en charge les graphiques de calcul dynamiques et en facilitant le débogage.

Caractéristiques de Pytorch Mobile

Vous trouverez ci-dessous quelques caractéristiques importantes de Pytorch Mobile:

• Modèles prédéfinis : Pytorch Mobile fournit une large gamme de modèles pré-formés qui peuvent être convertis en exécution sur des appareils mobiles.
• Graphiques dynamiques : c'est l'un des graphiques de calcul dynamiques de Pytorch qui permettent une flexibilité pendant le développement.
• Opérateurs personnalisés : Pytorch Mobile nous permet de créer des opérateurs personnalisés, ce qui peut être utile pour les cas d'utilisation avancés.

Comparaison des performances: Tensorflow Lite vs Pytorch Mobile

Lorsque nous discutons de leurs performances, les deux cadres sont optimisés pour les appareils mobiles, mais TensorFlow Lite a une vitesse d'exécution élevée et une efficacité des ressources.

• Vitesse d'exécution : TensorFlow Lite est généralement plus rapide en raison de son optimisation agressive, telle que la quantification et l'accélération basée sur les délégués. Par exemple - nnapi et gpu.
• Taille binaire : TensorFlow Lite a une empreinte plus petite, avec des tailles binaires aussi basses que 300 Ko pour les constructions minimales. Les binaires mobiles Pytorch ont tendance à être plus grands et nécessitent un réglage plus fin pour un déploiement léger.

Facilité d'utilisation et expérience des développeurs

Pytorch Mobile est généralement préféré par les développeurs en raison de sa flexibilité et de sa facilité de débogage. C'est à cause des graphiques de calcul dynamiques. Cela nous aide à modifier les modèles lors de l'exécution, ce qui est idéal pour le prototypage. D'un autre c?té, TensorFlow Lite nécessite que les modèles soient convertis en format statique avant le déploiement, ce qui peut ajouter de la complexité mais entra?ner des modèles plus optimisés pour le mobile.

• Conversion du modèle : Pytorch Mobile nous permet d'exporter direct des modèles Pytorch, tandis que TensorFlow Lite nécessite de convertir les modèles TensorFlow à l'aide du convertisseur Tflite.
• Débogage : le graphique dynamique de Pytorch facilite le débogage des modèles pendant qu'ils fonctionnent, ce qui est idéal pour repérer rapidement les problèmes. Avec le graphique statique de Tensorflow Lite, le débogage peut être un peu difficile bien que TensorFlow fournit des outils tels que Model Analyzer qui peuvent nous aider.

Plates-formes prises en charge et compatibilité des appareils

Nous pouvons utiliser TensorFlow Lite et Pytorch Mobile sur deux principales plates-formes mobiles, Android et iOS.

TensorFlow Lite

Lorsqu'il s'agit de choisir qui prendra en charge le matériel, TFLITE est beaucoup plus flexible. En raison du système de délégué, il prend en charge non seulement des CPU et des GPU, mais aussi des processeurs de signaux numériques (DSP) et d'autres puces qui sont considérées comme des interprètes plus élevés que les CPU de base.

Pytorch mobile

Bien que Pytorch Mobile prenne également en charge les CPU et les GPU tels que Metal for iOS et Vulkan pour Android, il a moins d'options pour l'accélération matérielle au-delà. Cela signifie que TFLITE peut avoir l'avantage lorsque nous avons besoin d'une compatibilité matérielle plus large, en particulier pour les appareils qui ont des processeurs spécialisés.

Conversion du modèle: de la formation au déploiement

La principale différence entre Tensorflow Lite et Pytorch Mobile est de savoir comment les modèles passent de la phase de formation à la déployée sur les appareils mobiles.

TensorFlow Lite

Si nous voulons déployer un modèle TensorFlow sur mobile, il doit être converti à l'aide du convertisseur Tflite. Ce processus peut être optimisé, comme la quantification qui rendra le modèle rapide et efficace pour les cibles mobiles.

Pytorch mobile

Pour Pytorch Mobile, nous pouvons enregistrer le modèle à l'aide de TorchScript. Le processus est très simple et plus facile, mais il n'offre pas le même niveau d'options d'optimisation avancées que Tflite fournit.

Des cas d'utilisation pour TensorFlow Lite et Pytorch Mobile

Explorez les applications réelles de Tensorflow Lite et Pytorch Mobile, montrant comment ces cadres alimentent les solutions intelligentes dans diverses industries.

TensorFlow Lite

Tflite est une meilleure plate-forme pour différentes applications qui nécessitent des réponses rapides telles que la classification d'images en temps réel ou la détection d'objets. Si nous travaillons sur des appareils avec du matériel spécialisé tel que les GPU ou les unités de traitement neuronal. Les fonctionnalités d'accélération matérielle de Tflite aident le modèle à s'exécuter plus rapidement et plus efficacement.

Pytorch mobile

Pytorch Mobile est idéal pour les projets qui évoluent encore, tels que la recherche ou les applications prototypes. Sa flexibilité facilite l'expérimentation et l'itération, ce qui permet aux développeurs d'apporter des changements rapides. Pytorch Mobile est idéal lorsque nous devons expérimenter fréquemment et déployer de nouveaux modèles avec des modifications minimales.

Implémentation de TensorFlow Lite

Nous utiliserons un modèle pré-formé (MobileNetv2) et le convertirons en TensorFlow Lite.

Chargement et économie du modèle

La première chose que nous faisons est d'importer TensorFlow et de charger un modèle mobileNetv2 pré-formé. Il est prêt à utiliser pour la pré-formation sur l'ensemble de données ImageNet, comme cela a été vu dans ce modèle. Le modèle.export ('mobilenet_model') écrit le modèle dans un format de SavedModel de TensorFlow. Il s'agit du format requis pour le convertir au modèle TensorFlow Lite (TFLITE) qui est utilisé avec les appareils mobiles.

 # étape 1: Configurez l'environnement et chargez un modèle mobileNetv2 pré-formé
Importer TensorFlow comme TF

# Chargez un modèle mobilenetv2 pré-entra?né
modèle = tf.keras.applications.mobilenetv2 (poids = 'ImageNet', input_shape = (224, 224, 3))

# Enregistrer le modèle en tant que la conversion SavedModel pour la conversion TFLITE
Model.Export ('Mobilenet_Model')

Convertir le modèle en TensorFlow Lite

Le modèle est chargé à partir du modèle enregistré (répertoire MobileNet_Model) à l'aide de TfliteConverter. Le convertisseur convertit le modèle en un format .tflite plus léger. Enfin, le modèle TFLITE est enregistré en tant que mobilenet_v2.tflite pour une utilisation ultérieure dans les applications mobiles ou de bord.

 # étape 2: Convertissez le modèle en TensorFlow Lite
converter = tf.lite.tfliteConverter.from_saved_model ('mobilenet_model')
tflite_model = converter.convert ()

# Enregistrer le modèle converti en un fichier tflite
avec open ('mobilenet_v2.tflite', 'wb') comme f:
    f.write (tflite_model)

Chargement du modèle Tflite pour l'inférence

Maintenant, nous importons les bibliothèques nécessaires pour les opérations numériques (Numpy) et la manipulation d'image (pil.image). Le modèle Tflite est chargé à l'aide de la mémoire tf.lite.interpreterand est alloué pour les tenseurs d'entrée / de sortie. Nous récupérons des détails sur les tenseurs d'entrée / sortie, comme les formes et les types de données, qui seront utiles lorsque nous prétraions l'image d'entrée et récupérons la sortie.

 Importer Numpy comme NP
à partir de l'image d'importation PIL

# Chargez le modèle TFLITE et allouez les tenseurs
interprète = tf.lite.interpreter (modèle_path = 'mobilenet_v2.tflite')
interpréter.ALLOCOT_tensers ()

# Obtenez des tenseurs d'entrée et de sortie
input_details = interpréter.get_input_details ()
output_details = interprère.get_output_details ()

Entrée de prétraitement, fonctionnement de l'inférence et décodage

Nous chargeons l'image (cat.jpg), le redimensionnez aux pixels requis (224, 224) et le prétraitez en utilisant la méthode de prétraitement de MobileNetv2. L'image prétraitée est introduite dans le modèle TFLITE en définissant le tenseur d'entrée à l'aide de l'Interpreter.set_tensor (), et nous exécutons l'inférence à l'aide d'interpreter.invoke (). Après l'inférence, nous récupérons les prédictions du modèle et les décodons en noms et probabilités de classe lisibles par l'homme à l'aide de decode_predictions (). Enfin, nous imprimons les prédictions.

 # Charger et prétraiter l'image d'entrée
image = image.open ('cat.jpg'). redimensionner ((224, 224)) # Remplacez par votre chemin d'image
input_data = np.expand_dims (np.array (image), axe = 0)
input_data = tf.keras.applications.mobilenet_v2.preprocess_input (input_data)

# Définissez le tenseur d'entrée et exécutez le modèle
interpréter.set_tensor (input_details [0] ['index'], input_data)
interprète.invoke ()

# Obtenez les prédictions de sortie et de décodage
output_data = interprère.get_tensor (output_details [0] ['index'])
Predictions = tf.keras.applications.mobilenet_v2.decode_predictions (output_data)
Impression (prédictions)

Utilisez l'image du chat ci-dessous:

Sortir:

[('N02123045', 'Tabby', 0,85), ('N02124075', 'Egyptian_cat', 0,07), ('N02123159', 'Tiger_cat', 0,05)]]

Cela signifie que le modèle est confiant à 85% que l'image est un chat tabby.

Implémentation mobile Pytorch

Maintenant, nous allons implémenter Pytorch Mobile. Nous utiliserons un modèle pré-formé simple comme RESNET18, le convertir en torchscript et exécuter l'inférence

Configuration de l'environnement et chargement du modèle RESNET18

 # étape 1: configurer l'environnement
Importer une torche
Importer TorchVision.Models comme modèles

# Chargez un modèle RESNET18 pré-entra?né
modèle = modèles.resnet18 (prétrainé = true)

# Définissez le modèle sur le mode d'évaluation
Model.Eval ()

Convertir le modèle en torchscript

Ici, nous définissons un exemple_input, qui est un tenseur aléatoire de taille [1, 3, 224, 224]. Cela simule un lot de 1 image avec 3 canaux de couleur (RVB) et 224 × 224 pixels. Il est utilisé pour tracer les opérations du modèle. Torch.jit.trace () est une méthode qui convertit le modèle Pytorch en module TorchScript. TorchScript vous permet de sérialiser et d'exécuter le modèle en dehors de Python, comme dans les appareils C ou mobiles. Le modèle TORCHScript converti est enregistré en tant que ?resnet18_scripted.pt?, ce qui lui permet d'être chargé et utilisé plus tard.

 # étape 2: Convertir en torchscript
Exemple_input = torch.randn (1, 3, 224, 224) # Exemple d'entrée pour le tra?age
traced_script_module = torch.jit.trace (modèle, exemple_input)

# Enregistrer le modèle TORCHScript
traced_script_module.save ("resnet18_scripted.pt")

Chargez le modèle scripté et faites des prédictions

Nous utilisons Torch.jit.load () pour charger le modèle TorchScript précédemment enregistré du fichier ?resnet18_scripted.pt?. Nous créons un nouveau tenseur aléatoire Input_data, simulant à nouveau une entrée d'image avec la taille [1, 3, 224, 224]. Le modèle est ensuite exécuté sur cette entrée à l'aide de charged_model (input_data). Cela renvoie la sortie, qui contient les scores bruts (logits) pour chaque classe. Pour obtenir la classe prévue, nous utilisons Torch.max (sortie, 1) qui donne l'indice de la classe avec le score le plus élevé. Nous imprimons la classe prévue en utilisant prédit.item ().

 # étape 3: Chargez et exécutez le modèle scripté
chargé_model = torch.jit.load ("resnet18_scripted.pt")

# Simuler les données d'entrée (un tenseur d'image aléatoire)
input_data = torch.randn (1, 3, 224, 224)

# Exécutez le modèle et obtenez des prédictions
output = charded_model (input_data)
_, prédit = torch.max (sortie, 1)
Print (F'predit Class: {prédit.item ()} ')

Sortir:

Classe prévue: 107

Ainsi, le modèle prédit que les données d'entrée appartiennent à l'indice de classe 107.

Conclusion

Tensorflow Lite donne davantage l'accent sur les appareils mobiles tandis que Pytorch Mobile fournit une solution plus générale provoquée par CPU / GPU, toutes deux optimisées pour les différentes applications de l'IA sur les appareils mobiles et bords. Par rapport à Tensorflow Lite, Pytorch Mobile offre une plus grande portabilité tout en étant plus léger que TensorFlow Lite et étroitement intégré à Google. Combinés, ils permettent aux développeurs de mettre en ?uvre des applications d'intelligence artificielle en temps réel avec des fonctionnalités élevées sur les appareils portables des développeurs. Ces cadres permettent aux utilisateurs la capacité d'exécuter des modèles sophistiqués sur les machines locales et, ce faisant, ils réécrivent les règles sur la fa?on dont les applications mobiles s'engagent avec le monde, via le bout des doigts.

Principaux à retenir

• Tensorflow Lite et Pytorch Mobile Deveroders Offowers pour déployer efficacement les modèles d'IA sur les appareils Edge.
• Les deux cadres prennent en charge la compatibilité multiplateforme, améliorant la portée des applications AI mobiles.
• Tensorflow Lite est connu pour l'optimisation des performances, tandis que Pytorch Mobile excelle en flexibilité.
• La facilité d'intégration et les outils adaptés aux développeurs rendent les deux cadres adaptés à une large gamme de cas d'utilisation de l'IA.
• Les applications réelles couvrent des industries telles que les soins de santé, la vente au détail et le divertissement, présentant leur polyvalence.

Questions fréquemment posées

A. Tensorflow Lite est utilisé où nous avons besoin de hautes performances sur les appareils mobiles tandis que Pytorch Mobile est utilisé lorsque nous avons besoin de flexibilité et de facilité d'intégration avec l'écosystème existant de Pytorch.

A. Oui, TensorFlow Lite et Pytorch Mobile travaillent sur Android et iOS.

A. Pytorch Mobile est utile pour les applications qui effectuent des taches telles que l'image, le visage et la classification vidéo, la détection d'objets en temps réel, la conversion de la parole à texte, etc.

A. Tensorflow Lite Mobile est utile pour des applications telles que la robotique, les appareils IoT, la réalité augmentée (AR), la réalité virtuelle (VR), le traitement du langage naturel (PNL), etc.

Les médias présentés dans cet article ne sont pas détenus par l'analytique vidhya et sont utilisés à la discrétion de l'auteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!