Compiler Et Optimiser Le Modèle À L'aide De TVMC
Contenu en un coup d'œil :Cette section explique comment compiler et optimiser le modèle à l'aide de TVMC. TVMC est le pilote de commande de TVM, qui exécute les fonctions TVM via des lignes de commande. Cette section constitue la base pour comprendre le fonctionnement de TVM.
Mots-clés:TVMC TVM Apprentissage automatique
Cette section présente TVMC, le pilote de ligne de commande pour TVM. TVMC exécute les fonctions TVM via l'interface de ligne de commande(Y compris le réglage automatique, la compilation, l'analyse et l'exécution des modèles).
Après avoir terminé cette section,Les tâches suivantes peuvent être accomplies à l’aide de TVMC :
- Compilez le modèle ResNet-50 v2 pré-entraîné pour l'exécution TVM.
- Utilisez le modèle compilé pour prédire des images réelles et expliquer la sortie et les performances du modèle.
- Utilisez TVM pour régler le modèle sur le CPU.
- Recompilez le modèle optimisé à l’aide des données de réglage collectées par TVM.
- Prédisez les images à l’aide des modèles optimisés et comparez la sortie et les performances du modèle.
Cette section fournit un aperçu des fonctions de TVM et TVMC et pose les bases pour comprendre le fonctionnement de TVM.
Utilisation de TVMC
TVMC est une application Python et fait partie du package Python TVM.Lorsque vous installez TVM à l'aide du package Python, vous obtiendrez un tvmc Application en ligne de commande pour . L'emplacement de cette commande varie en fonction de la plate-forme et de la méthode d'installation.
De plus, si $PYTHONPATH S'il existe un module Python appelé TVM sur le , vous pouvez utiliser le module Python exécutable (avec python -m tvm.driver.tvmc (commande) pour accéder à la fonctionnalité du pilote de ligne de commande.
Ce tutoriel utilise tvmc ou python -m tvm.driver.tvmc pour ouvrir la ligne de commande TVMC.
Utilisez la commande suivante pour afficher la page d’aide :
tvmc --helptvmc Les principales fonctions de TVM sont disponibles à partir de sous-commandes compiler , courir et régler . utiliser tvmc –aide Afficher les options spécifiques pour une sous-commande donnée.
Ce tutoriel présentera ces commandes. Avant de commencer, veuillez télécharger un modèle pré-entraîné.
Obtenez le modèle
Dans ce tutoriel, nous utiliserons ResNet-50 v2. ResNet-50 est un réseau neuronal convolutif profond à 50 couches pour la classification d'images.Le modèle que nous utiliserons ensuite a été pré-entraîné sur plus d’un million d’images de 1 000 catégories différentes. La taille de l’image d’entrée de ce réseau est de 224 × 224.
Je recommande de télécharger Netron (un visualiseur de modèles ML gratuit) pour explorer plus en profondeur la structure organisationnelle du modèle ResNet-50.
Téléchargez Netron : https://netron.app/
Ce tutoriel utilise le modèle au format ONNX :
wget https://github.com/onnx/models/raw/b9a54e89508f101a1611cd64f4ef56b9cb62c7cf/vision/classification/resnet/model/resnet50-v2-7.onnxConseils 1 Formats de modèles pris en charge :
TVMC prend en charge les modèles créés avec Keras, ONNX, TensorFlow, TFLite et Torch. Disponible --format-modèle L'option indique le format de modèle utilisé. mettre en œuvre tvmc compile –aide pour plus d'informations.
Conseils 2 : Ajoutez la prise en charge d'ONNX à TVM :
TVM s'appuie sur la bibliothèque Python ONNX disponible sur votre système. Installez ONNX en utilisant pip3 install –user onnx onnxoptimizer . Si vous disposez d’un accès root et souhaitez installer ONNX globalement, vous pouvez supprimer l’option –user. La dépendance onnxoptimizer est facultative et requise uniquement pour onnx>=1.9.
Compiler le modèle ONNX vers TVM Runtime
Après avoir téléchargé le modèle ResNet-50, utilisez compilation tvmc Compilez-le. Le résultat de la compilation est une archive TAR du modèle (compilée dans une bibliothèque dynamique pour la plate-forme cible). Utilisez l'environnement d'exécution TVM pour exécuter le modèle sur le périphérique cible :
# 大概需要几分钟，取决于设备
tvmc compile \
--target "llvm" \
--input-shapes "data:[1,3,224,224]" \
--output resnet50-v2-7-tvm.tar \
resnet50-v2-7.onnxVérifier compilation tvmc Fichiers créés dans le module :
mkdir model
tar -xvf resnet50-v2-7-tvm.tar -C model
ls modelIl y a trois fichiers après décompression :
* mod.so Il s'agit d'un modèle qui peut être chargé par le runtime TVM, représenté sous la forme d'une bibliothèque C++.
* mod.json Il s'agit d'une représentation textuelle du graphe de calcul du relais TVM.
* mod.params est un fichier contenant les paramètres du modèle pré-entraîné.
Les modules peuvent être chargés directement par les applications, tandis que les modèles peuvent être exécutés via l'API d'exécution TVM.
Conseils 3 : Définissez la bonne CIBLE :
Spécifiez la cible correcte (option --cible ) peuvent grandement améliorer les performances des modules compilés car ils peuvent tirer parti des fonctionnalités matérielles disponibles sur la cible. Consultez Réglage automatique des réseaux convolutifs pour les processeurs x86 pour plus d'informations. Il est recommandé de déterminer le modèle de processeur et les fonctionnalités optionnelles à utiliser, puis de définir la cible de manière appropriée.
Exécuter des modèles à partir de modules compilés à l'aide de TVMC
Après avoir compilé le modèle dans un module, vous pouvez utiliser l'environnement d'exécution TVM pour faire des prédictions dessus. TVMC dispose d'un runtime TVM intégré, permettant d'exécuter des modèles TVM compilés.
Pour exécuter un modèle et faire des prédictions à l'aide de TVMC, vous avez besoin de :
- Le module compilé vient d'être généré.
- Entrées valides pour le modèle utilisé pour la prédiction.
La forme, le format et le type de données des tenseurs varient selon les modèles.Par conséquent, la plupart des modèles nécessitent un prétraitement et un post-traitement pour garantir que l’entrée est valide et que la sortie peut être interprétée. TVMC utilise NumPy .npz Format d'entrée et de sortie, qui prend bien en charge la sérialisation de plusieurs tableaux dans un seul fichier.
L'image d'entrée utilisée dans ce tutoriel est une image de chat, mais vous pouvez choisir d'autres images de votre choix.
Prétraitement des entrées
L'entrée du modèle ResNet-50 v2 doit être au format ImageNet. Vous trouverez ci-dessous un exemple de script pour le prétraitement d'une image avec ResNet-50 v2.
Première utilisation pip3 install –utilisateur pillow Téléchargez la bibliothèque d'imagerie Python pour satisfaire la dépendance du script à la bibliothèque d'imagerie.
#!python ./preprocess.py
from tvm.contrib.download import download_testdata
from PIL import Image
import numpy as np
img_url = "https://s3.amazonaws.com/model-server/inputs/kitten.jpg"
img_path = download_testdata(img_url, "imagenet_cat.png", module="data")
# 重设大小为 224x224
resized_image = Image.open(img_path).resize((224, 224))
img_data = np.asarray(resized_image).astype("float32")
# ONNX 需要 NCHW 输入, 因此对数组进行转换
img_data = np.transpose(img_data, (2, 0, 1))
# 根据 ImageNet 进行标准化
imagenet_mean = np.array([0.485, 0.456, 0.406])
imagenet_stddev = np.array([0.229, 0.224, 0.225])
norm_img_data = np.zeros(img_data.shape).astype("float32")
for i in range(img_data.shape[0]):
norm_img_data[i, :, :] = (img_data[i, :, :] / 255 - imagenet_mean[i]) / imagenet_stddev[i]
# 添加 batch 维度
img_data = np.expand_dims(norm_img_data, axis=0)
# 保存为 .npz（输出 imagenet_cat.npz）
np.savez("imagenet_cat", data=img_data)Exécuter le module compilé
Avec le modèle et les données d'entrée, exécutons TVMC pour faire des prédictions :
tvmc run \
--inputs imagenet_cat.npz \
--output predictions.npz \
resnet50-v2-7-tvm.tar.goudron Le fichier modèle comprend une bibliothèque C++, un fichier de description du modèle Relay et un fichier de paramètres du modèle. TVMC inclut l'environnement d'exécution TVM (qui peut charger des modèles et faire des prédictions sur les entrées). Exécutez la commande ci-dessus, TVMC générera un nouveau fichier prédictions.npz, qui contient les tenseurs de sortie du modèle au format NumPy.
Dans cet exemple, le modèle est compilé sur la même machine que celle qui l'exécute. Dans certains cas, il peut être possible de l'exécuter à distance à l'aide de RPC Tracker. Vérifier tvmc run –aide pour en savoir plus sur ces options.
Post-traitement de sortie
Comme mentionné précédemment, chaque modèle fournit des tenseurs de sortie différemment.
Dans cet exemple, nous devons exécuter un post-traitement pour rendre la sortie de ResNet-50 v2 sous une forme plus lisible à l'aide de la table de recherche fournie pour ce modèle.
Le script suivant est un exemple de post-traitement qui extrait les étiquettes de la sortie d'un module compilé :
#!python ./postprocess.py
import os.path
import numpy as np
from scipy.special import softmax
from tvm.contrib.download import download_testdata
# 下载标签列表
labels_url = "https://s3.amazonaws.com/onnx-model-zoo/synset.txt"
labels_path = download_testdata(labels_url, "synset.txt", module="data")
with open(labels_path, "r") as f:
labels = [l.rstrip() for l in f]
output_file = "predictions.npz"
# 打开并读入输出张量
if os.path.exists(output_file):
with np.load(output_file) as data:
scores = softmax(data["output_0"])
scores = np.squeeze(scores)
ranks = np.argsort(scores)[::-1]
for rank in ranks[0:5]:
print("class='%s' with probability=%f" % (labels[rank], scores[rank]))Le résultat de l’exécution de ce script est le suivant :
python postprocess.py
# class='n02123045 tabby, tabby cat' with probability=0.610553
# class='n02123159 tiger cat' with probability=0.367179
# class='n02124075 Egyptian cat' with probability=0.019365
# class='n02129604 tiger, Panthera tigris' with probability=0.001273
# class='n04040759 radiator' with probability=0.000261Remplacez l’image du chat ci-dessus par d’autres images et voyez quelles prédictions le modèle ResNet fait.
Ajuster automatiquement le modèle ResNet
Les modèles précédents étaient compilés pour s'exécuter sur l'environnement d'exécution TVM et ne contenaient donc pas d'optimisations spécifiques à la plate-forme.Cette section présentera comment utiliser TVMC pour créer un modèle d'optimisation pour la plate-forme de travail.
Lorsque vous raisonnez avec des modules compilés, vous n’obtiendrez peut-être pas toujours les performances attendues.Dans ce cas, l'auto-tuner peut être utilisé pour mieux configurer le modèle et ainsi améliorer les performances.. Le réglage du TVM consiste à optimiser le modèle sur une cible donnée pour le rendre plus rapide. Contrairement à la formation ou au réglage fin, cela n’affecte pas la précision du modèle, mais uniquement les performances d’exécution.
Dans le cadre du processus de réglage,TVM implémente et exécute de nombreuses variantes de différents opérateurs pour voir lequel fonctionne le mieux.Les résultats de ces exécutions sont stockés dans le fichier journal de réglage (la sortie finale de la commande de réglage).
Le réglage doit au moins inclure :
- Exigences de la plate-forme pour les appareils cibles exécutant ce modèle
- Chemin d'accès au fichier de sortie où sont stockés les enregistrements de réglage
- Le chemin vers le modèle à régler.
L'exemple suivant illustre son flux de travail :
# 默认搜索算法需要 xgboost，有关调优搜索算法的详细信息，参见下文
pip install xgboost
tvmc tune \
--target "llvm" \
--output resnet50-v2-7-autotuner_records.json \
resnet50-v2-7.onnxDans ce cas, --cible Lorsque vous spécifiez une cible plus spécifique avec l'indicateur, vous obtiendrez de meilleurs résultats. Par exemple, sur un processeur Intel i7, vous pouvez utiliser –cible llvm -mcpu=skylake . Cet exemple de réglage utilise LLVM comme compilateur pour une architecture spécifique et effectue un réglage natif sur le processeur.
TVMC recherche l'espace des paramètres du modèle, essaie différentes configurations pour les opérateurs, puis choisit la configuration qui s'exécute le plus rapidement sur la plateforme. Bien qu'il s'agisse d'une recherche guidée basée sur les opérations du processeur et du modèle, il faut encore plusieurs heures pour terminer la recherche. Le résultat de la recherche sera enregistré dans resnet50-v2-7-autotuner_records.json fichier, qui est ensuite utilisé pour compiler le modèle optimisé.
Conseils 4 Définir et ajuster l’algorithme de recherche :
Cet algorithme de recherche utilise la valeur par défaut Grille XGBoost Guide de l'algorithme. En fonction de la complexité du modèle et du temps disponible, différents algorithmes peuvent être choisis. La liste complète peut être consultée Réglage tvmc – aide .
Pour un processeur Skylake grand public, le résultat est le suivant :
Compiler et optimiser le modèle à l'aide des données de réglage
À partir du fichier de sortie du processus de réglage ci-dessus `resnet50-v2-7-autotuner_records.json Vous pouvez obtenir des enregistrements de réglage.
Ce fichier peut être utilisé pour :
- En tant qu'entrée pour un réglage ultérieur (via Enregistrements de réglage de TVMC ）
- En entrée du compilateur
mettre en œuvre compilation tvmc –tuning-records La commande indique au compilateur d’utiliser ce résultat pour générer du code hautes performances pour le modèle sur la cible spécifiée. Vérifier tvmc compile –aide pour plus d'informations.
Une fois les données de réglage du modèle collectées, le modèle peut être recompilé avec des opérateurs optimisés pour accélérer le calcul.
tvmc compile \
--target "llvm" \
--tuning-records resnet50-v2-7-autotuner_records.json \
--output resnet50-v2-7-tvm_autotuned.tar \
resnet50-v2-7.onnxVérifiez que le modèle d’optimisation s’exécute et produit les mêmes résultats :
tvmc run \
--inputs imagenet_cat.npz \
--output predictions.npz \
resnet50-v2-7-tvm_autotuned.tar
python postprocess.pyVérifiez que les valeurs prédites sont les mêmes :
# class='n02123045 tabby, tabby cat' with probability=0.610550
# class='n02123159 tiger cat' with probability=0.367181
# class='n02124075 Egyptian cat' with probability=0.019365
# class='n02129604 tiger, Panthera tigris' with probability=0.001273
# class='n04040759 radiator' with probability=0.000261Comparaison des modèles réglés et non réglés
TVMC fournit des outils d'évaluation des performances de base entre les modèles.Vous pouvez spécifier le nombre de répétitions ainsi que l'heure à laquelle le modèle de rapport TVMC doit être exécuté (indépendamment du démarrage de l'exécution). Vous pouvez avoir une idée approximative de la mesure dans laquelle le réglage a amélioré les performances du modèle.
Par exemple, lorsqu'il est testé sur un système Intel i7, le modèle réglé exécute 47% plus rapidement que le modèle non réglé :
tvmc run \
--inputs imagenet_cat.npz \
--output predictions.npz \
--print-time \
--repeat 100 \
resnet50-v2-7-tvm_autotuned.tar
# Execution time summary:
# mean (ms) max (ms) min (ms) std (ms)
# 92.19 115.73 89.85 3.15
tvmc run \
--inputs imagenet_cat.npz \
--output predictions.npz \
--print-time \
--repeat 100 \
resnet50-v2-7-tvm.tar
# Execution time summary:
# mean (ms) max (ms) min (ms) std (ms)
# 193.32 219.97 185.04 7.11Derniers mots
Ce tutoriel présente TVMC, le pilote de ligne de commande pour TVM.Il montre comment compiler, exécuter et ajuster les modèles et discute de la nécessité d'un pré-traitement et d'un post-traitement des entrées et des sorties.Après le réglage, montrez comment comparer les performances des modèles non optimisés et optimisés.
Ce document montre un exemple simple d’utilisation locale de ResNet-50 v2. Cependant, TVMC prend en charge davantage de fonctionnalités, notamment la compilation croisée, l'exécution à distance et le profilage/l'analyse comparative.
utiliser tvmc –aide commande pour voir les autres options disponibles.
Le prochain tutoriel, Compilation et optimisation d'un modèle avec l'interface Python, présentera les mêmes étapes de compilation et d'optimisation à l'aide de l'interface Python.
Continuez à suivre, ne le manquez pas~