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.
Cet article a été publié dans le cadre du Blogathon de la science des données.
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.
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é.
Vous trouverez ci-dessous quelques caractéristiques les plus importantes de TensorFlow Lite:
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.
Vous trouverez ci-dessous quelques caractéristiques importantes de 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.
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.
Nous pouvons utiliser TensorFlow Lite et Pytorch Mobile sur deux principales plates-formes mobiles, Android et iOS.
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.
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.
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.
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.
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.
Explorez les applications réelles de Tensorflow Lite et Pytorch Mobile, montrant comment ces cadres alimentent les solutions intelligentes dans diverses industries.
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 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.
Nous utiliserons un modèle pré-formé (MobileNetv2) et le convertirons en TensorFlow Lite.
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')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)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 ()
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.
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
# É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 ()
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")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.
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.
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.
Q2. Tensorflow Lite et Pytorch Mobile peuvent-ils fonctionner sur Android et iOS?A. Oui, TensorFlow Lite et Pytorch Mobile travaillent sur Android et iOS.
Q3. Écrivez une utilisation de Pytorch Mobile.A. Pytorch Mobile est utile pour les applications qui effectuent des tâches 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.
Q4. Écrivez une utilisation de Tensorflow Lite Mobile.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!
la fonction direct3d n'est pas disponible
Mon ordinateur ne peut pas l'ouvrir en double-cliquant dessus.
Introduction aux outils de développement logiciel
Utilisation du mot-clé Type dans Go
Introduction au contenu principal du travail du backend
Tutoriel sur l'achat et la vente de Bitcoin sur Huobi.com
Comment utiliser la fonction countif
Quelle est la devise du PROM ?
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
