Assez rapide sur un processeur
- Leçon 28
- 40 min
- Module 8 : Exploiter la vision en production
Où nous en sommes
Nous savons maintenant repérer les changements dans les photos fournies à un modèle. Le modèle doit aussi répondre rapidement sur l'ordinateur ordinaire de l'entrepôt, sans carte graphique. Dans cette leçon, nous réduisons l'image, regroupons les photos en lots, exportons vers ONNX et utilisons des nombres de 8 bits. Nous mesurons le temps et l'exactitude après chaque étape.
Leçon 28 sur 30 · IA de vision : voir, compter et inspecterAssez rapide sur un processeur
1. Voir est un problème d'affaires
2. Références de base et classificateurs préentraînés
3. Plongements, CLIP et peu d'étiquettes
4. Détecter et compter
5. Segmenter
6. Inspecter pour trouver les défauts
7. Apparier, chercher et décrire
8. Exploiter la vision en production
Ce que vous saurez faire
Rendez un modèle de vision assez rapide pour l’ordinateur qui l’exécutera, sans perdre d’exactitude par accident. Chaque changement peut modifier le temps et l’exactitude : image plus petite, lot, nouveau format de fichier ou nombres plus petits. Mesurez donc les deux après chaque changement, sur l’ordinateur qui compte.
Carnet JupyterFaites cette leçon dans un carnet Jupyter
Le carnet (notebook) Jupyter contient toutes les cellules de code, tâches et vérifications de cette leçon. Il mesure ResNet-18 à trois tailles d’image, avec un lot, après exportation vers ONNX et après quantification en int8. Ses cellules de préparation installent PyTorch, ONNX et ONNX Runtime. Elles téléchargent aussi les photos du catalogue et les poids de ResNet-18 (47 Mo). Environ 40 minutes, dont environ 1 minute de calcul sur un ordinateur portable.
Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les plongements et les sondes linéaires, vus dans Les plongements d’images et Sondes linéaires et quelques exemples.
- Le petit PatchCore, vu dans L’inspection par détection d’anomalies.
Ce qu’il vous faut sur votre ordinateur (pour les étapes du projet; le carnet n’en a pas besoin)
- Votre projet
larkvisionà la fin du module 8 (instantanéC42/snapshots/end-of-m08), préparé dans Le décalage de domaine, avec son environnement.venv.
Tous les temps de cette leçon ont été mesurés sur un seul ordinateur portable (Apple M4). Vos temps seront différents. Tests effectués sur macOS avec Python 3.12.13, PyTorch 2.15.0, ONNX 1.23.2 et ONNX Runtime 1.31.1. Les commandes Windows sont fournies, mais n’ont pas été exécutées.
La file au comptoir des retours
Section intitulée « La file au comptoir des retours »Une employée au comptoir des retours prend une bougie, la photographie et attend la réponse. Si la réponse prend une seconde, elle attend une seconde. Avec 600 retours par jour, l’attente s’accumule et la file de cartons s’allonge.
Le temps entre « photo reçue » et « réponse fournie » est la latence. Au comptoir de Hamid, la latence d’une photo compte, car une personne attend chaque réponse.
Le problème : « petit » et « rapide » ne veulent pas dire la même chose
Section intitulée « Le problème : « petit » et « rapide » ne veulent pas dire la même chose »Le comptoir des retours de Larkfield utilise un ordinateur de bureau ordinaire, sans carte graphique, qui exécute aussi d’autres programmes. Amira veut que l’inspecteur utilise un seul fil d’exécution (une seule ligne de travail sur le processeur), pour ne pas ralentir le reste.
Tomás a une réponse simple : « Prenez le plus petit modèle. » MobileNetV3 est un réseau conçu pour les téléphones : 22 Mo contre 47 Mo pour ResNet-18. Priya a mesuré les deux avec un seul fil d’exécution, une photo à la fois :
| Modèle, dans PyTorch, un fil d’exécution | Taille | Temps par photo |
|---|---|---|
| ResNet-18 | 47 Mo | 10,2 ms |
| MobileNetV3 | 22 Mo | 84,9 ms |
Le plus petit modèle était huit fois plus lent sur cet ordinateur portable. MobileNetV3 utilise des types de couches que PyTorch exécute mal sur ce processeur. Une fiche de modèle (model card) ne peut pas vous le dire. Seule une mesure sur votre ordinateur le peut.
L’idée : un changement à la fois, deux mesures chaque fois
Section intitulée « L’idée : un changement à la fois, deux mesures chaque fois »Il existe cinq façons courantes d’accélérer un modèle de vision sur un processeur (CPU) :
- Une image plus petite. Une photo de 160 × 160 pixels contient environ la moitié des pixels d’une photo de 224 × 224. Le réseau fait donc environ la moitié du travail.
- Un lot. Envoyez plusieurs photos dans un seul appel. Les coûts fixes de l’appel sont partagés.
- Exporter vers ONNX. ONNX (Open Neural Network Exchange) est un format de fichier pour un réseau entraîné. ONNX Runtime, une petite bibliothèque, exécute le fichier sans PyTorch.
- La quantification int8. Stockez les poids et faites les calculs avec des nombres entiers de 8 bits plutôt que des nombres décimaux de 32 bits (fp32).
- Un réseau de base plus petit. Un autre réseau, comme MobileNetV3.
Après chaque changement, mesurez deux choses : le temps par photo et l’exactitude sur les mêmes photos de test. Ici, l’exactitude vient du test du catalogue, avec une régression logistique équilibrée sur les plongements du réseau, comme au module 3.
Description textuelle du diagramme
Trois encadrés en rangée (empilés sur un téléphone). Le premier indique « modèle PyTorch » : 47 Mo, nécessite PyTorch. Une flèche, « exporter (un appel) », mène à « fichier ONNX (fp32) » : 45 Mo, nécessite ONNX Runtime. Une deuxième flèche, « quantifier (64 photos) », mène à « fichier ONNX (int8) », en vert : 11 Mo, nécessite ONNX Runtime. Une phrase en dessous indique : vérifiez l’exactitude et le temps après chaque étape, car chacune peut modifier les deux.
Un tout petit exemple : les nombres int8
Section intitulée « Un tout petit exemple : les nombres int8 »Quatre poids d’une couche : −0,80, −0,10, 0,25 et 1,20. int8 stocke des nombres entiers de −128 à 127, avec un facteur d’échelle pour la couche. Le plus grand poids, 1,20, doit devenir 127. Le facteur d’échelle est donc 1,20 ÷ 127 = 0,00945.
| Poids (fp32, 4 octets) | ÷ facteur d’échelle | Valeur stockée (int8, 1 octet) | × facteur d’échelle à nouveau | Erreur |
|---|---|---|---|---|
| −0,80 | −84,7 | −85 | −0,803 | 0,003 |
| −0,10 | −10,6 | −11 | −0,104 | 0,004 |
| 0,25 | 26,5 | 26 | 0,246 | 0,004 |
| 1,20 | 127,0 | 127 | 1,200 | 0,000 |
Chaque poids occupe 1 octet plutôt que 4, ce qui rend le fichier environ quatre fois plus petit. Chaque poids change de moins d’un demi-pas d’échelle. Les calculs avec des nombres entiers sont aussi plus rapides sur la plupart des processeurs. La question est de savoir si des milliers de petites erreurs comme celles-ci changent les réponses. Seule une mesure le révèle.
Pour les nombres qui circulent dans le réseau (pas les poids), ONNX Runtime a besoin de leur intervalle de valeurs. Il fait passer quelques photos dans le réseau pour le trouver : c’est l’étalonnage. Le cours a utilisé 64 photos d’entraînement.
Larkfield : ResNet-18, un changement à la fois
Section intitulée « Larkfield : ResNet-18, un changement à la fois »Priya a mesuré chaque étape sur l’ordinateur portable du cours, avec un seul fil d’exécution et une photo à la fois :
Description textuelle du graphique
Un graphique à cinq colonnes. PyTorch à 224 pixels : 10,17 ms. PyTorch à 160 pixels : 6,22 ms. PyTorch à 128 pixels : 5,16 ms. ONNX en fp32, 224 pixels : 17,14 ms, le plus lent. ONNX en int8, 224 pixels : 8,4 ms.
Le tableau complet, avec l’exactitude et la taille :
| Changement | Exactitude | Temps par photo (1 fil d’exécution) | Lot de 16 (par photo) | Fichier |
|---|---|---|---|---|
| ResNet-18, PyTorch, 224 pixels | 0,850 | 10,2 ms | 16,7 ms | 47 Mo |
| Image de 160 pixels | 0,838 | 6,2 ms | 8,9 ms | 47 Mo |
| Image de 128 pixels | 0,838 | 5,2 ms | 7,0 ms | 47 Mo |
| ONNX fp32, 224 | 0,850 | 17,1 ms | 23,4 ms | 44,7 Mo |
| ONNX int8, 224 | 0,856 | 8,4 ms | 8,4 ms | 11,3 Mo |
| MobileNetV3, PyTorch | 0,881 | 84,9 ms | 59,8 ms | 22 Mo |
| MobileNetV3, ONNX fp32 | 0,881 | 7,1 ms | 10,0 ms | 16,8 Mo |
| MobileNetV3, ONNX int8 | 0,869 | 3,4 ms | 3,6 ms | 4,7 Mo |
Lisez-le une ligne à la fois :
- Les images plus petites ont réduit le temps, au prix de 2 photos sur 160 (0,850 → 0,838). Une photo représente 0,6 point; c’est donc proche du bruit.
- Un lot de 16 était plus lent par photo avec un seul fil d’exécution. Les lots aident quand plusieurs photos attendent en même temps et que l’ordinateur dispose de fils d’exécution libres. Le comptoir de Hamid envoie une photo à la fois.
- ONNX fp32 était plus lent que PyTorch avec un seul fil d’exécution. L’exportation n’accélère pas le modèle à elle seule. Son intérêt est que le service n’a plus besoin de PyTorch.
- int8 a rétabli la vitesse et rendu le fichier quatre fois plus petit. L’exactitude n’a pas baissé ici : 0,856 représente une photo de plus que 0,850, ce qui relève du bruit.
- MobileNetV3 n’est rapide qu’après exportation : 84,9 ms dans PyTorch, 3,4 ms dans ONNX int8. Le même réseau, deux moteurs d’exécution, un écart de 25 fois.
La surprise du lot, dans le carnet
Section intitulée « La surprise du lot, dans le carnet »Le carnet répète les étapes de ResNet-18 sur votre ordinateur. Sur l’ordinateur portable du cours, le carnet de solution a affiché :
accuracy, PyTorch, 224 pixels: 0.85ms a photo, one at a time, 1 thread: 9.8ms a photo, batch of 16, 1 thread: 16.7ms a photo, one at a time, 4 threads: 6.6ONNX file: 44.7 MBaccuracy, ONNX fp32: 0.85ms a photo, ONNX fp32, 1 thread: 16.9int8 file: 11.3 MBaccuracy, ONNX int8: 0.856ms a photo, ONNX int8, 1 thread: 8.7Une deuxième exécution a donné 9,4 ms et 8,4 ms pour les mêmes lignes. Les temps varient de quelques pour cent d’une exécution à l’autre. Comparez les temps mesurés sur le même ordinateur, pendant la même exécution. Les exactitudes ne changent pas.
L’inspecteur du service d’images
Section intitulée « L’inspecteur du service d’images »Le service d’images ne classe pas les produits. Il inspecte les retours avec le petit PatchCore du module 6. Amira lui a appliqué les mêmes deux étapes : exporter les premières couches de ResNet-18 vers ONNX, puis quantifier en int8.
| Petit PatchCore | Fichier du modèle | Mémoire des bons fragments | Temps par photo | AUROC de test | Coût par jour (test) |
|---|---|---|---|---|---|
| 32 bits (module 6) | 11,1 Mo | 15,4 Mo | 17,8 ms | 0,847 | 1 290,8 |
| int8 (le service) | 2,9 Mo | 15,4 Mo | 15,1 ms | 0,836 | 988,1 |
Ces temps ont été mesurés avec quatre fils d’exécution. Le tableau du module 6 indiquait 78 Mo pour la même méthode. Il comptait le fichier ResNet-18 entier et une mémoire en nombres de 32 bits. Ici, le fichier du modèle contient seulement les couches utilisées par l’inspecteur, et la mémoire utilise des nombres de 16 bits. int8 a légèrement changé les scores. Priya a donc choisi à nouveau les seuils sur les photos de validation. L’AUROC a baissé de 0,011. Le coût par jour a aussi baissé. Mais avec 18 photos de test endommagées, ce n’est pas un véritable gain. Une bougie endommagée de plus ou de moins change le coût de centaines de dollars. La conclusion juste est : « qualité à peu près identique, fichier quatre fois plus petit et aucun besoin de PyTorch ».
Le service a seulement besoin d’ONNX Runtime, NumPy, Pillow et OpenCV. Avec ces bibliothèques, l’environnement du projet passe d’environ 230 Mo à 447 Mo. L’environnement du carnet de cette leçon, avec PyTorch, occupait environ 1,2 Go.
Le code : larkvision/inspector.py
Section intitulée « Le code : larkvision/inspector.py »class Inspector: """Loads models/inspector/: model.onnx, bank.npy and config.json (lines and validation statistics)."""
def __init__(self, folder, threads=1): import onnxruntime as ort folder = Path(folder) self.config = json.loads((folder / "config.json").read_text()) so = ort.SessionOptions() so.intra_op_num_threads = threads self.session = ort.InferenceSession(str(folder / "model.onnx"), so, providers=["CPUExecutionProvider"]) self.bank = np.load(folder / "bank.npy").astype(np.float32) self.bank_sq = (self.bank ** 2).sum(1) self.version = self.config["version"]
def score(self, img): f = self.session.run(None, {"image": preprocess(img)})[0][0] q = f.reshape(f.shape[0], -1).T d2 = (q ** 2).sum(1)[:, None] + self.bank_sq[None] - 2 * q @ self.bank.T return float(np.sqrt(max(d2.min(1).max(), 0.0)))intra_op_num_threads = threads fixe le nombre de fils d’exécution, un par défaut. Le score est la distance entre le pire fragment et son bon fragment le plus proche, comme au module 6.
Mesurer le temps de l’inspecteur dans le projet
Section intitulée « Mesurer le temps de l’inspecteur dans le projet »-
Ouvrez un terminal dans votre dossier
larkvisionet activez l’environnement (source .venv/bin/activate, ou.venv\Scripts\Activate.ps1sur Windows). -
Dans un nouveau terminal, définissez à nouveau
LARKVISION_DATAetLARKVISION_MODELS, avec les commandes de l’étape 6 de Le décalage de domaine. -
Évaluez trois photos de test : une bonne bougie, une bougie avec un surplus de cire et une bougie à mèche pliée. Sur macOS et Linux :
Fenêtre de terminal vision inspect ../nextia-learning-labs/C42/data/returns/test/R-6a26ad64.jpg ../nextia-learning-labs/C42/data/returns/test/R-33640732.jpg ../nextia-learning-labs/C42/data/returns/test/R-1cc8cc10.jpgSur Windows, écrivez les chemins avec
..\nextia-learning-labs\C42\data\returns\test\.R-6a26ad64: pass score 5.832 confidence 0.33 37 msR-33640732: check score 9.924 confidence 0.00 21 ms -> review: unsure: the score is between the two linesR-1cc8cc10: fail score 19.445 confidence 0.80 22 ms -
Lisez les temps. La première photo prend plus de temps (37 ms) : le premier appel prépare le modèle. Les suivantes prennent environ 21 ms. Ce temps inclut aussi un détecteur de visages, expliqué dans la dernière leçon de ce module.
Les scores et les zones devraient être identiques sur votre ordinateur, ou très proches. Les temps ne le seront pas. La prochaine leçon explique la confiance et le dossier de révision.
Quand utiliser chaque changement, et ce qu’il coûte
Section intitulée « Quand utiliser chaque changement, et ce qu’il coûte »Utilisez ONNX et int8 quand le modèle doit fonctionner sur un processeur sans PyTorch, comme dans le service d’Amira. Utilisez une image plus petite quand les détails nécessaires restent visibles. Rappelez-vous la tache de couleur dans Quand ne pas le construire. Elle occupait moins d’un pixel à 224 pixels de largeur et disparaîtrait à 128. Utilisez un lot quand plusieurs photos attendent en même temps, par exemple une tâche nocturne sur tout le catalogue.
Ne faites pas confiance à une accélération que vous n’avez pas mesurée sur l’ordinateur cible. Et ne sautez pas la mesure d’exactitude après int8. Ici, elle s’est maintenue, mais elle peut baisser de plusieurs points avec un autre réseau ou d’autres photos.
Ce que cela coûte : chaque changement crée une nouvelle version du modèle. Il faut mesurer et noter à nouveau son exactitude, son temps et son fichier. L’exportation peut échouer avec des couches inhabituelles, et l’étalonnage nécessite des photos qui ressemblent aux vraies. Un autre coût n’est pas technique. Les poids de ResNet-18 et de MobileNetV3 ont été appris avec ImageNet. Vérifiez donc leur utilisation dans un produit, comme dans La licence fait partie des critères pour être « prêt ». Déployer des modèles d’IA pour de vrais utilisateurs traite de l’exploitation d’un modèle avec des versions et une façon de revenir en arrière.
Exercice guidé : les étapes dans le carnet
Section intitulée « Exercice guidé : les étapes dans le carnet »- Ouvrez le carnet dans l’encadré Faites cette leçon dans un carnet Jupyter, en haut de cette page.
- Exécutez les cellules de préparation. La cellule des paquets affiche une ligne par paquet. La cellule des données se termine par une ligne
Ready:(prêt). - Dans la section 1, exécutez la cellule. Vous voyez
accuracy, PyTorch, 224 pixels: 0.85(exactitude, PyTorch, 224 pixels : 0,85) et votre temps. - Dans la section 2, faites une prédiction, puis exécutez la cellule. Vous voyez
0.838. - Dans la section 3, exécutez la cellule. Comparez le lot de 16 avec une photo à la fois sur votre ordinateur.
- Dans la section 4, exécutez la cellule d’exportation. Vous voyez
accuracy, ONNX fp32: 0.85(exactitude, ONNX fp32 : 0,85). - Dans la section 5, exécutez la cellule int8. ONNX Runtime affiche un avertissement sur le « prétraitement » : il est sans danger ici. Vous voyez
int8 file: 11.3 MB(fichier int8 : 11,3 Mo) etaccuracy, ONNX int8: 0.856(exactitude, ONNX int8 : 0,856).
À vous de jouer : une image encore plus petite
Section intitulée « À vous de jouer : une image encore plus petite »Changez une seule chose : la taille d’image, à 128 × 128 pixels, dans PyTorch. Avant l’exécution, faites une prédiction : l’exactitude sera-t-elle plus proche de 0,838 ou de 0,80? Dans la section 6 du carnet, mettez l’exactitude dans acc_128, puis exécutez la cellule de vérification.
Afficher la réponse
acc_128 = accuracy(pytorch, 128)print(acc_128, ms_per_photo(pytorch, 128))0.838 5.2La même exactitude qu’à 160 pixels, et environ la moitié du temps nécessaire à 224. Pour les types de produits, la forme et la couleur du produit entier restent visibles à 128. Pour l’inspecteur de Hamid, cela ne suffirait pas : une petite tache de couleur a besoin de chaque pixel.
Erreur courante
Une seule mesure, sur le mauvais ordinateur
Symptôme : Tomás mesure une fois le temps de l’inspecteur sur son ordinateur portable, avec tous ses fils d’exécution. Il écrit « 4 ms par photo » dans le plan. Sur l’ordinateur du comptoir, avec un fil d’exécution et d’autres programmes ouverts, les premières photos prennent dix fois plus de temps.
Cause : il a mesuré un appel, qui inclut la préparation, sur un autre ordinateur, avec un nombre différent de fils d’exécution. Le premier appel de vision inspect a pris 37 ms ici, et les suivants environ 21 ms.
Correction : mesurez sur l’ordinateur cible, ou sur un ordinateur semblable. Fixez le nombre de fils d’exécution. Faites un appel de préparation, puis mesurez le temps de nombreuses photos. Indiquez la valeur médiane (p50) et une valeur lente (p95), comme le fait vision replay.
Conséquence pour le travail en IA : une promesse de latence jamais mesurée sur le véritable ordinateur échoue dès la première journée chargée. La file au comptoir s’allonge alors.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Les poids d'une couche sont −0,60, 0,15 et 0,90. Avec int8 et une seule échelle pour la couche (le plus grand poids devient 127), quelle est l'échelle? Quelle valeur stocke-t-on pour 0,15, et quelle valeur obtient-on ensuite?
Afficher la réponse
L’échelle est 0,90 ÷ 127 = 0,00709. Pour 0,15 : 0,15 ÷ 0,00709 = 21,2, stocké sous la forme 21. Au retour : 21 × 0,00709 = 0,149, soit une erreur d’environ 0,001. Le poids occupe 1 octet au lieu de 4.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Avec un seul fil d'exécution, ResNet-18 exporté en ONNX fp32 était plus lent que PyTorch (17,1 contre 10,2 ms). Pourquoi Amira l'a-t-elle quand même exporté?
Afficher la réponse
L’exportation ne sert pas principalement à accélérer le modèle. Le fichier ONNX fonctionne avec ONNX Runtime seul, donc le service n’a pas besoin de PyTorch. Le service devient ainsi plus petit et plus simple à installer. L’exportation est aussi l’étape avant int8 : le fichier ONNX int8 prenait 8,4 ms avec la même exactitude (0,856 contre 0,850, une photo). Son fichier fait 11,3 Mo au lieu de 47 Mo.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
MobileNetV3 en ONNX int8 prend 3,4 ms par photo avec une exactitude de 0,869. ResNet-18 en ONNX int8 prend 8,4 ms avec une exactitude de 0,856. Le poste de Hamid envoie une photo toutes les quelques secondes. Lequel choisiriez-vous pour les types de produits, et que mesureriez-vous avant de changer?
Afficher la réponse
Les deux dépassent largement la vitesse nécessaire au poste. L’écart entre 0,869 et 0,856 représente environ deux photos sur 160, ce qui se rapproche du bruit. Les deux conviennent. MobileNetV3 est plus petit (4,7 Mo), donc c’est un choix raisonnable. Avant de changer, mesurez sa vitesse sur l’ordinateur cible avec un seul fil d’exécution. Mesurez aussi l’exactitude pour chaque classe et chaque tranche, pas seulement l’exactitude globale. Vérifiez également sa licence et ses données d’entraînement, comme pour ResNet-18.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Mesurez deux choses après chaque changement : le temps par photo sur l’ordinateur cible et l’exactitude sur les mêmes photos de test.
- « Petit » ne veut pas dire « rapide » : MobileNetV3 prenait 84,9 ms dans PyTorch avec un seul fil d’exécution, et 3,4 ms en ONNX int8.
- ONNX fp32 était plus lent que PyTorch avec un seul fil d’exécution (17,1 contre 10,2 ms), mais il élimine PyTorch du service. int8 donnait 8,4 ms, 11,3 Mo et la même exactitude (0,856).
- Un lot de 16 était plus lent par photo avec un seul fil d’exécution. Des images plus petites gagnaient du temps, mais coûtaient environ 2 photos sur 160.
- Le petit PatchCore du service en int8 : 2,9 Mo, AUROC de test de 0,836 contre 0,847 en 32 bits : une qualité à peu près équivalente, sans PyTorch.
vision inspectévalue les photos en environ 21 ms chacune après un premier appel plus lent.
L’inspecteur est maintenant rapide et léger. Ensuite, Amira le rend accessible sous forme de petit service web. Il répond avec un niveau de confiance et fait appel à une personne quand il ne peut pas juger. Son dossier de révision fournit de nouvelles étiquettes sans biais.
Leçon suivante : Le service d'images et sa file de révision