Comment Ultralytics YOLO pour améliorer leur vitesse sur les processeurs, les cartes graphiques et les appareils périphériques. Nous vous expliquerons le fonctionnement des puces, de la mémoire et des techniques intelligentes telles que la quantification, la fusion et l'élagage.
Chez Ultralytics, nous créons des modèles de vision par ordinateur ; en gros, nous apprenons aux ordinateurs à voir ! Considérez ces modèles comme des recettes mathématiques géantes. Ils sont composés d'opérations (que nous appelons couches) et d'une énorme pile de chiffres que nous appelons poids.
NosYOLO Ultralytics YOLO traitent les images telles qu'elles sont réellement : des tableaux de chiffres ! Chaque pixel n'est en réalité qu'une valeur de couleur, la quantité de rouge, de vert et de bleu (d'où le sigle RVB) pour chaque point qui compose l'image. Nous appelons ces tableaux de chiffres des « tenseurs », car cela sonne beaucoup mieux que « matrices multidimensionnelles », qui sonne déjà beaucoup mieux que « chiffres empilés sur des chiffres empilés sur des chiffres ».
Lorsque vous introduisez une image dans notre modèle, celle-ci entreprend un voyage épique à travers le réseau. Imaginez votre tensor à travers les couches les unes après les autres, se transformant, se convoluant et se déformant mathématiquement de la plus belle manière possible. Considérez cela comme une soirée dansante où les chiffres se mélangent et s'entremêlent, extrayant l'essence même de ce qui fait qu'un chat est un chat ou qu'une voiture est une voiture. Nous appelons ce processus « extraction de caractéristiques ».
Qu'est-ce qui en ressort ? Encore plus de chiffres ! Des chiffres significatifs. Dans les tâches de détection, ils vous indiquent exactement où se trouvent les éléments dans votre image et ce qu'ils sont probablement. « Hé, il y a 95 % de chances que ce soit un chien aux coordonnées (x, y) ! » Nous appelons ce processus magique « inférence ».
Avant que nos modèles puissent faire leur travail, ils doivent aller à l'école, ils doivent être formés. C'est là que les choses deviennent intenses.
Pendant l'entraînement, chaque fois que nous présentons une image au réseau, nous n'obtenons pas seulement une réponse. Nous effectuons deux tâches extrêmement lourdes. Tout d'abord, nous calculons l'erreur commise par le réseau (ce que nous appelons la perte, qui correspond essentiellement à la distance par rapport à la cible). Ensuite, et c'est là le plus important, nous mettons à jour chaque chiffre (ou poids) du réseau en fonction de cette perte. Imaginez que vous réglez des milliers de petits boutons en même temps, chaque ajustement étant calculé pour rendre le réseau plus précis à chaque fois. Nous entraînons essentiellement le réseau par correction : chaque erreur lui apprend ce qu'il ne faut PAS faire, et nous ajustons tous ces poids afin que, lorsqu'il voit à nouveau une image similaire, il se rapproche de la bonne réponse. En substance, le réseau apprend en étant poussé dans la bonne direction, erreur après erreur, jusqu'à ce qu'il commence à faire des prédictions exactes.
De combien de chiffres parlons-nous ? Eh bien, notre adorable petit YOLO11n possède quelques millions de paramètres. Mais YOLO11x ? Ce petit malin possède plus de 50 millions de paramètres ! Plus il y a de paramètres, plus vous pouvez encoder de détails, comme la différence entre dessiner avec des crayons de couleur et disposer d'une palette complète d'artiste.
Lors de l'inférence, ce nombre de paramètres devient crucial. Exécuter un réseau de 3 millions de paramètres, c'est comme faire un jogging autour du pâté de maisons. Exécuter un réseau de 50 millions de paramètres ? C'est plutôt comme courir un marathon tout en jonglant avec des torches enflammées.
Alors, qu'est-ce que le calcul exactement ? Comment tout ce traitement de données s'effectue-t-il concrètement ? Comment l'accélérer ? Et que signifie « optimiser le calcul » ?
Le calcul s'effectue à l'aide de puces. Ces petits carrés de silicium sont en quelque sorte les châteaux de sable les plus organisés de l'univers. Chaque opération effectuée par votre ordinateur, chaque addition, chaque comparaison, chaque « si ceci alors cela », est physiquement gravée dans le silicium. Il existe des circuits physiques réels dans des zones spécifiques de la puce dédiés à l'addition de nombres, et d'autres pour les opérations logiques. C'est comme avoir une petite ville où différents quartiers sont spécialisés dans différents types de mathématiques.
Cela peut sembler bizarre, même si vous êtes informaticien. C'est parce que nous avons passé les 40 dernières années à construire couche après couche d'abstraction, comme une lasagne technologique qui est devenue si haute que nous ne pouvons même plus voir la plaque inférieure. Nous avons tellement simplifié les choses que la plupart des programmeurs d'aujourd'hui n'ont aucune idée de la façon dont le calcul se fait réellement dans le silicium. Ce n'est pas de leur faute, mais bien celle de la conception !
Décortiquons ces couches. Prenons ce Python extrêmement simple :
x = 1
if x == 1:
y = x + 1Nous créons une variable x, nous lui attribuons la valeur 1, et si x est égal à 1 (spoiler : c'est le cas), nous créons y avec la valeur de x plus 1. Trois lignes. Facile.
Mais c'est là que ça devient intéressant. Entre ces trois lignes innocentes et les électrons qui se déplacent réellement dans le silicium, il y a AU MOINS quatre couches massives de traduction (il y en a en fait davantage, mais notre responsable du contenu numérique dit que mon nombre de mots lui donne déjà de l'anxiété). Laissez-moi vous guider à travers ce voyage époustouflant :
Couche 1 : Python Bytecode Tout d'abord, Python votre code et le compile en un langage intermédiaire appelé bytecode, plus facile à comprendre pour les ordinateurs, mais qui vous donnerait mal aux yeux si vous essayiez de le lire.
Couche 2 : Bytecode → Code machine L Python (comme CPython) prend ce bytecode et le traduit en code machine, c'est-à-dire les instructions réelles que votre processeur comprend. C'est là que votre élégant « if x == 1 » devient quelque chose comme « LOAD register, COMPARE register, JUMP if zero flag set ».
Couche 3 : Code machine → Microcode Rebondissement ! Les processeurs modernes n'exécutent même pas directement le code machine. Ils le décomposent en microcode, des opérations encore plus petites que les composants internes de la puce peuvent traiter. Votre instruction « ADD » unique peut se transformer en plusieurs micro-opérations.
Couche 4 : Microcode → Électronique physique Enfin, nous arrivons au silicium. Ces micro-opérations déclenchent des signaux électriques réels qui circulent à travers les transistors. Des milliards de minuscules commutateurs s'activent et se désactivent, les électrons dansent à travers des chemins soigneusement conçus, et d'une manière ou d'une autre, comme par magie, 1 + 1 devient 2.
Chaque couche existe pour masquer la complexité insensée de la couche située en dessous. C'est comme ces poupées russes gigognes, sauf que chaque poupée parle une langue complètement différente et que la plus petite poupée est littéralement faite d'éclairs emprisonnés dans du sable.
L'ironie ? Ces trois lignes de Python déclenchent Python des MILLIONS de commutations de transistors. Mais grâce à ces abstractions, vous n'avez pas besoin de vous soucier de tout cela. Vous écrivez simplement « y = x + 1 » et vous avez confiance que quelque part, au plus profond du silicium, la magie opère.
Chaque opération est physiquement mise en œuvre dans le silicium, et son emplacement sur la puce dépend entièrement de la topologie de celle-ci. C'est comme l'urbanisme, mais pour les électrons. L'additionneur se trouve ici, le multiplicateur là, et ils doivent tous communiquer efficacement entre eux.
Il existe des centaines de puces différentes sur le marché, chacune étant conçue pour des usages différents. Qu'est-ce qui les différencie ? La topologie, c'est-à-dire la manière dont les opérations sont positionnées et mises en œuvre dans le domaine physique. C'est ce que nous appelons l'architecture, et croyez-moi, il en existe une multitude :
Chaque architecture organise non seulement ses transistors différemment, mais utilise également un langage différent. Les abstractions que nous utilisons pour envoyer des instructions à ces machines sont complètement différentes. C'est comme si vous deviez écrire un itinéraire pour quelqu'un, mais que, selon le type de voiture de cette personne, vous deviez l'écrire en français, en mandarin ou en danse expressive.
Le carburant de nos puces est constitué d'électrons, l'électricité qui circule dans la puce et fournit l'énergie nécessaire au calcul. Mais l'énergie seule ne suffit pas. Pour qu'une puce fonctionne réellement, pour que les données circulent à travers sa topologie complexe, tout dépend d'un composant essentiel : l'horloge. C'est elle qui fait circuler les électrons à travers des chemins spécifiques à des moments précis. Sans elle, vous n'auriez qu'un morceau de silicium alimenté en énergie qui ne ferait rien.
Imaginez que vous essayez de coordonner un spectacle gigantesque où des milliards d'éléments doivent bouger en parfaite synchronisation. Sans rythme, ce serait le chaos. C'est exactement ce que fait l'horloge pour votre processeur. C'est un cristal qui vibre à une fréquence incroyablement régulière, envoyant des impulsions électriques des milliards de fois par seconde.
Lorsque vous entendez « processeur 3,5 GHz », ce GHz (gigahertz) correspond à la vitesse d'horloge, soit 3,5 milliards d'impulsions par seconde. Chaque impulsion est appelée cycle d'horloge et constitue l'unité de temps fondamentale en informatique.
RIEN ne se passe entre les cycles d'horloge. L'ordinateur entier se fige, attendant le prochain battement. C'est comme le jeu le plus extrême de feu rouge, feu vert de l'univers. À chaque « feu vert » (impulsion d'horloge) :
Certaines opérations ne prennent qu'un cycle (une simple addition), tandis que d'autres en prennent plusieurs (une division ou la récupération de données dans la mémoire RAM). Tout est chorégraphié avec précision, des milliards de composants exécutent leurs opérations spécifiques, tous synchronisés à ce rythme implacable.
Vous pouvez overclocker votre processeur en faisant vibrer le cristal plus rapidement ; tout se passe plus vite, mais cela génère également plus de chaleur, ce qui le rend moins stable. Si vous allez trop loin, votre ordinateur plante car les électrons ne peuvent littéralement pas suivre le rythme.
À l'époque, ces opérations étaient réalisées à l'aide de machines aussi grandes que des pièces. Mais les composants qui effectuent tous ces calculs sont remarquablement simples : ce ne sont que des interrupteurs. Des interrupteurs marche-arrêt.
Il suffit de relier suffisamment de ces commutateurs selon le bon schéma pour obtenir un calcul. Toute la révolution numérique repose sur un agencement sophistiqué de commutateurs.
Cette simplicité signifie que si vous disposez de commutateurs, quels qu'ils soient, vous pouvez construire un ordinateur. Des gens ont construit des ordinateurs fonctionnels à partir de tuyaux et de vannes d'eau, de dominos, de blocs LEGO, de billes et même avec de la redstone dans Minecraft.
Les principes n'ont pas changé depuis les années 1940. Nous sommes simplement devenus incroyablement doués pour fabriquer des commutateurs extrêmement petits. Votre téléphone a plus de puissance de calcul que tous les ordinateurs qui ont envoyé des hommes sur la Lune, et il tient dans votre poche parce que nous avons trouvé comment fabriquer des commutateurs à l'échelle atomique.
Lorsque nous exécutons des réseaux neuronaux avec des millions de paramètres, nous actionnons ces minuscules commutateurs des milliards de fois par seconde, le tout parfaitement synchronisé avec ce battement de cœur cristallin. Chaque mise à jour de poids, chaque multiplication matricielle, chaque fonction d'activation, tout cela marche au rythme de l'horloge.
Pas étonnant que les modèles d'entraînement donnent l'impression que votre ordinateur tente de décoller !
Bon, nous avons donc ces puces avec des milliards de commutateurs qui dansent au rythme d'un cristal, et nous voulons y faire fonctionner des réseaux neuronaux avec des millions de paramètres. Ça devrait être facile, non ? Il suffit d'entrer les chiffres dans la puce et de la laisser faire !
Exécuter rapidement des réseaux neuronaux, c'est comme essayer de préparer un repas cinq services dans une cuisine où le réfrigérateur se trouve à trois pâtés de maisons, où vous n'avez qu'une seule poêle et où chaque ingrédient pèse 500 livres. Le calcul en lui-même n'est pas le plus gros problème, c'est tout le reste.
La plupart des puces ont été conçues pour faire tourner Microsoft , pas des réseaux neuronaux. Votre CPU conçu pour passer sa vie à exécuter des instructions if, des boucles et, parfois, à calculer vos impôts (le seul calcul que même les superordinateurs trouvent émotionnellement épuisant). Il est optimisé pour les opérations séquentielles : faire ceci, puis cela, puis autre chose.
Mais les réseaux neuronaux sont complètement différents. Ils veulent TOUT FAIRE EN MÊME TEMPS. Pendant l'entraînement, vous mettez à jour des millions de poids en fonction de l'erreur de vos prédictions. Pendant l'inférence (l'utilisation effective du modèle entraîné), vous soumettez les données à des millions de calculs simultanés. Imaginez que vous deviez multiplier un million de nombres par un autre million de nombres. Votre CPU, Dieu merci, veut les traiter un par un, comme un comptable très rapide mais très méthodique.
C'est pourquoi les GPU sont devenus la colonne vertébrale de l'informatique IA. Les GPU ont été conçus pour les jeux vidéo, où il faut calculer simultanément la couleur de millions de pixels. Il s'avère que le calcul des couleurs des pixels et les calculs des réseaux neuronaux sont étonnamment similaires : les deux impliquent d'effectuer la même opération en parallèle sur d'énormes quantités de données.
Mais même les GPU ne sont pas parfaits pour les réseaux neuronaux. C'est pourquoi les entreprises développent désormais des puces IA spécialisées (TPU, NPU et toutes les autres abréviations se terminant par PU). Ces puces sont conçues dès le départ dans un seul but : accélérer les réseaux neuronaux. C'est comme si vous engagiez un chef qui ne sait cuisiner qu'un seul plat, mais qui le prépare à une vitesse surhumaine. Alors que votre CPU effectuer des opérations matricielles de manière séquentielle et que votre GPU les GPU assez bien en parallèle, ces puces spécialisées dévorent les matrices au petit-déjeuner, au déjeuner et au dîner.
Dans les calculs modernes des réseaux neuronaux, nous consacrons plus de temps et d'énergie à DÉPLACER les données qu'à les CALCULER.
Imaginez que votre puce informatique soit un brillant mathématicien qui travaille à la vitesse de l'éclair, mais dont tous les ouvrages de référence sont stockés dans différents bâtiments à travers la ville. Il peut résoudre n'importe quelle équation instantanément, mais il doit d'abord récupérer les chiffres, et ce trajet prend une éternité.
Votre puce peut multiplier deux nombres en un cycle d'horloge (rappelez-vous, cela correspond à l'un de ces milliards d'impulsions par seconde). Une vitesse fulgurante ! Mais transférer ces nombres de la mémoire à la puce ? Cela peut prendre des CENTAINES de cycles. C'est comme si votre mathématicien pouvait résoudre un problème en une seconde, mais avait besoin de cinq minutes pour aller à la bibliothèque et revenir.
La raison en est la distance (et l'espace). L'électricité se déplace rapidement, mais pas à une vitesse infinie. Plus les données doivent parcourir une longue distance sur la puce, plus cela prend du temps. Les concepteurs d'ordinateurs ont résolu ce problème en créant une hiérarchie de mémoire, comme s'il y avait plusieurs emplacements de stockage à différentes distances :
Les structures exactes varient : la puce de votre téléphone peut ignorer le cache L3, tandis qu'un CPU de serveur CPU en contenir une quantité considérable. Le principe reste toutefois le même : une mémoire plus proche est plus rapide, mais plus petite.
C'est là que les réseaux neuronaux rencontrent des difficultés. Imaginez que votreYOLO Ultralytics YOLO comporte 50 millions de paramètres (ChatGPT des milliards, soit dit en passant). Cela représente 50 millions de chiffres qui doivent être transférés de la mémoire vers les unités de calcul, puis revenir. Même si chaque chiffre ne fait que 4 octets, cela représente 200 mégaoctets de données qui doivent transiter par votre système.
La puce peut traiter chaque nombre en un seul cycle, mais s'il faut 100 cycles pour récupérer ce nombre dans la mémoire RAM, vous passez 99 % de votre temps à attendre la livraison. C'est comme avoir une voiture de Formule 1 dans un embouteillage. Toute cette puissance de calcul, qui reste là, à attendre que les données arrivent.
Voici l'idée cruciale : c'est LE goulot d'étranglement de l'informatique moderne. On l'appelle le goulot d'étranglement de von Neumann. Il est relativement facile d'accélérer les puces pour les calculs mathématiques. Accélérer la mémoire atteint des limites physiques. C'est pourquoi presque TOUTES les optimisations de performances en IA se font au niveau de la mémoire. Lorsque les ingénieurs accélèrent les réseaux neuronaux, ils accélèrent rarement les calculs mathématiques ; ils trouvent des moyens astucieux pour déplacer moins de données, mieux les mettre en cache ou y accéder plus intelligemment.
Les puces IA modernes ne se concentrent pas uniquement sur la vitesse de calcul ; elles accordent une importance capitale à la bande passante mémoire et aux stratégies de transfert de données. Elles préchargent les données, réutilisent les valeurs déjà présentes dans le cache et organisent les calculs afin de minimiser les allers-retours vers la mémoire. Les gagnants dans la course au matériel IA ne sont pas ceux qui possèdent les calculateurs les plus rapides, mais ceux qui ont trouvé le moyen d'alimenter ces calculateurs en données. Tout repose sur l'optimisation des modèles d'accès à la mémoire.
Chaque fois que vous déplacez un peu de données, vous consommez de l'énergie. Pas beaucoup, on parle de picojoules, mais lorsque vous déplacez des téraoctets par seconde, cela s'accumule RAPIDEMENT. En fait, déplacer des données sur 1 mm à travers une puce consomme plus d'énergie que le calcul lui-même !
C'est pourquoi votre ordinateur portable fait autant de bruit qu'un réacteur d'avion lorsque vous entraînez des réseaux neuronaux. Ce ne sont pas les calculs mathématiques qui génèrent de la chaleur, mais le transfert de données. Chaque mise à jour des paramètres, chaque calcul de gradient, chaque passage vers l'avant réchauffe littéralement votre pièce.
Les accélérateurs IA modernes sont essentiellement des exercices de thermodynamique. Quelle quantité de calculs pouvons-nous intégrer avant que la puce ne fonde ? À quelle vitesse pouvons-nous évacuer la chaleur ? C'est comme l'overclocking, mais l'horloge est toujours réglée sur 11, et nous essayons simplement d'éviter de déclencher un incendie.
Les réseaux neuronaux les plus rapides ne sont pas nécessairement les plus intelligents, ce sont ceux qui sont conçus en tenant compte des puces. Ils :
C'est comme la différence entre une recette qui dit « utilisez les ingrédients de votre épicerie locale » et une autre qui vous oblige à importer des épices du Tibet, du fromage de France et de l'eau de l'Antarctique. Les deux peuvent être délicieuses, mais l'une est nettement plus pratique.
C'est pourquoi accélérer les réseaux neuronaux relève de l'art. Il ne suffit pas d'avoir de bonnes connaissances en mathématiques ; il faut comprendre le matériel, respecter la hiérarchie de la mémoire et s'adapter parfaitement à l'architecture.
Bienvenue dans un monde où l'informatique rencontre la physique, l'ingénierie et la magie pure. Où déplacer un nombre coûte plus cher que de l'utiliser dans un calcul. Où le parallélisme est rapide, mais où la synchronisation est mortelle. Où votre plus grand ennemi n'est pas la complexité, mais la distance.
Lorsque vous entraînez un YOLO , vous obtenez un réseau neuronal qui fonctionne à merveille sur votre configuration d'entraînement. Mais voici le problème : votre GPU de jeu, votre iPhone et cette minuscule puce dans une caméra de sécurité parlent tous des langages complètement différents. Ils ont des forces et des faiblesses différentes, et des idées très différentes sur la manière de traiter les données.
Pensez-y de cette façon : un GPU milliers de cœurs qui peuvent tous fonctionner simultanément – il est conçu pour le traitement parallèle. Quant à une puce mobile, elle peut être dotée de circuits spéciaux conçus spécifiquement pour les opérations d'IA, mais ne peut traiter que certains types de calculs mathématiques. Et cet appareil périphérique intégré à votre caméra de sonnette ? Il tente d'exécuter l'IA avec une consommation électrique inférieure à celle d'une ampoule LED.
Chez Ultralytics, nous prenons en charge plus d'une douzaine de formats d'exportation différents, car chacun d'entre eux est optimisé pour différents matériels. Il ne s'agit pas d'avoir trop d'options, mais plutôt d'avoir l'option adaptée à VOS besoins spécifiques.
Dans le YOLO original, de nombreuses opérations s'effectuent de manière séquentielle. Par exemple, nous pouvons effectuer une convolution, puis normaliser les résultats, puis appliquer une fonction d'activation. Cela représente trois étapes distinctes, chacune nécessitant ses propres lectures et écritures en mémoire.
Mais voici l'astuce : nous pouvons combiner ces opérations en une seule étape. Lorsque nous exportons YOLO le déploiement, nous fusionnons ces opérations. Au lieu de :
Nous faisons :
Pour un YOLO classique traitant une image de 640 × 640 pixels, cette astuce simple permet d'éliminer plusieurs gigaoctets de transferts de mémoire inutiles. Sur un téléphone mobile, cela fait toute la différence entre une détection fluide en temps réel et un décalage frustrant.
YOLO besoin de chiffres ultraprécis pour detect avec exactitude. Pendant l'entraînement, nous utilisons 32 bits pour représenter chaque poids, ce qui revient à utiliser une calculatrice scientifique pour mesurer les ingrédients d'un sandwich. Pour un déploiement réel ? 8 bits suffisent amplement.
C'est ce qu'on appelle la quantification, et c'est l'une de nos techniques d'optimisation les plus puissantes. En utilisant des nombres plus petits :
Toutes les couches de YOLO ne YOLO pas également sensibles à cette réduction. Les premières couches qui detect les contours et les formes detect ? Elles sont robustes : nous pouvons utiliser des nombres de 8 bits sans aucun problème. Les dernières couches de détection qui déterminent « s'agit-il d'un chat ou d'un chien ? » nécessitent un peu plus de précision. Nous ajustons donc la précision couche par couche, en utilisant juste assez de bits pour maintenir la précision tout en maximisant la vitesse.
Nous avons constaté qu'avec une quantification minutieuse, Ultralytics YOLO 99,5 % de sa précision d'origine tout en fonctionnant trois fois plus rapidement sur les téléphones. C'est ce qui distingue un modèle de recherche d'un modèle que vous pouvez réellement utiliser dans le monde réel.
Il existe des dizaines de façons différentes d'effectuer la même opération mathématique. Une simple convolution (l'opération centrale dans YOLO) peut être calculée à l'aide d'algorithmes complètement différents, et le meilleur choix dépend de votre matériel spécifique et de la taille de l'entrée.
Lorsque nous exportons YOLO, notre cadre d'optimisation teste différents algorithmes et sélectionne le plus rapide pour votre cas spécifique. C'est comme si vous aviez plusieurs itinéraires pour atteindre la même destination et que vous choisissiez celui qui convient le mieux en fonction des conditions de circulation actuelles. Sur un GPU, nous pouvons utiliser un algorithme qui traite simultanément de nombreux pixels. Sur un CPU, nous pouvons utiliser un algorithme optimisé pour le traitement séquentiel. Le calcul est le même, mais la stratégie d'exécution est complètement différente.
Vous vous souvenez que nous avons dit que la mémoire était le véritable goulot d'étranglement de l'informatique moderne ? C'est particulièrement vrai pour YOLO. Le modèle peut comporter 50 millions de paramètres et, pendant l'inférence, il génère des gigaoctets de résultats intermédiaires. Le transfert de toutes ces données est souvent plus lent que le calcul lui-même.
Nous utilisons plusieurs astuces pour minimiser les mouvements de mémoire :
Planification intelligente: nous organisons les opérations de manière à ce que les données soient utilisées immédiatement, tant qu'elles se trouvent encore dans la mémoire cache rapide. Pour le réseau pyramidal YOLO, cela réduit le trafic mémoire de 40 %.
Mosaïque: au lieu de traiter une image entière en une seule fois, nous la divisons en mosaïques plus petites qui tiennent dans la mémoire cache. Cela signifie que le processeur peut travailler avec une mémoire locale rapide au lieu de devoir constamment aller chercher les données dans la mémoire principale, plus lente.
Réutilisation des tampons: plutôt que de créer constamment de nouvelles mémoires pour les résultats intermédiaires, nous réutilisons les mêmes tampons mémoire. C'est incroyablement efficace : toute l'infrastructure YOLO peut fonctionner avec seulement quelques tampons réutilisables.
Voici un fait surprenant : YOLO sont souvent surdimensionnés. Nous pouvons supprimer 30 % des canaux dans de nombreuses couches sans pratiquement aucun impact sur la précision. Cela ne réduit pas seulement la taille du modèle, cela le rend également plus rapide, car il y a littéralement moins de calculs à effectuer.
Le processus est élégant : nous analysons les parties du réseau qui contribuent le moins aux résultats finaux de détection, nous les supprimons, puis nous affinons le modèle pour compenser. Un modèle YOLO11m élagué peut être 30 % plus rapide tout en conservant 99 % de sa précision d'origine. Sur les appareils alimentés par batterie, ce gain d'efficacité peut se traduire par des heures de fonctionnement supplémentaires.
Différents processeurs sont performants dans différents domaines, et les différences de performances sont stupéfiantes. Le même modèle YOLO11n prend :
Il ne s'agit pas seulement de différences de vitesse liées à la fréquence d'horloge, mais aussi de différences architecturales fondamentales. Les GPU disposent de milliers de cœurs qui fonctionnent en parallèle, ce qui est parfait pour les convolutions YOLO. Les NPU mobiles sont dotés de circuits spécialisés conçus spécifiquement pour les réseaux neuronaux. Les CPU sont polyvalents, flexibles, mais non spécialisés.
La clé de l'optimisation réside dans l'adéquation entre les opérations YOLO et les points forts de chaque puce. Un GPU effectuer simultanément la même opération sur un grand nombre de données. Une NPU mobile ne prend peut-être en charge que certaines opérations, mais elle les exécute avec une efficacité incroyable. Une TPU périphérique TPU fonctionne TPU avec des entiers 8 bits, mais atteint une vitesse remarquable dans le cadre de cette contrainte.
Lorsque vous exportez un YOLO , quelque chose de remarquable se produit en arrière-plan. Nous ne nous contentons pas de convertir le format du fichier, nous compilons le modèle spécifiquement pour votre matériel cible. C'est comme la différence entre Google et un locuteur natif. Le processus de compilation :
Le compilateur peut réorganiser les opérations afin de mieux utiliser le cache de votre processeur, sélectionner des instructions spécialisées prises en charge par votre puce, voire utiliser l'apprentissage automatique pour trouver la meilleure stratégie d'optimisation. Oui, nous utilisons l'IA pour optimiser l'IA : l'avenir est déjà là !
Cette étape de compilation peut multiplier par dix les performances. Le même YOLO peut fonctionner au ralenti avec un code générique, mais voler avec des instructions correctement optimisées.
Parlons de ce qui se passe lorsque YOLO le monde réel, en particulier le monde difficile des périphériques de pointe. Imaginez une caméra de sécurité qui doit fonctionner YOLO pour détecter des objets. Elle est confrontée à des contraintes brutales :
Voici ce que l'optimisation permet d'obtenir dans la pratique. Une caméra de sécurité équipée de YOLO11s :
Nous avons réduit la consommation d'énergie de 80 % tout en améliorant les performances ! C'est ce qui distingue un appareil qui surchauffe et vide les batteries d'un autre qui fonctionne de manière fiable pendant des années.
La clé réside dans le choix des bons compromis. Sur les appareils périphériques, nous avons souvent tendance à :
Chez Ultralytics, nous suivons une approche systématique de l'optimisation. Tout d'abord, nous profilons le modèle afin de comprendre où le temps est réellement passé. Souvent, les goulots d'étranglement ne se trouvent pas là où on pourrait s'y attendre. Peut-être que 80 % du temps est passé dans seulement quelques couches, ou que les transferts de mémoire dominent le temps de calcul.
Ensuite, nous appliquons les optimisations de manière itérative :
Par exemple, avec le déploiement de YOLO11m sur un téléphone :
Chaque étape améliore les performances tout en conservant plus de 99 % de la précision d'origine. Le résultat ? Une détection d'objets en temps réel sur un appareil qui tient dans votre poche.
Les appareils modernes sont de plus en plus intelligents dans l'utilisation simultanée de plusieurs processeurs. Votre téléphone ne dispose pas d'un seul processeur, mais de plusieurs, chacun étant spécialisé dans différentes tâches :
L'avenir de YOLO réside dans la répartition intelligente du modèle entre ces processeurs. Peut-être que le NPU gère les principales convolutions, le CPU la logique de détection finale et le GPU les résultats. Chaque processeur fait ce qu'il fait le mieux, créant ainsi un pipeline plus efficace que ce qu'un seul processeur pourrait réaliser.
Nous développons des algorithmes de partitionnement intelligents qui déterminent automatiquement la meilleure façon de répartir YOLO les processeurs disponibles, en tenant compte non seulement de leurs capacités, mais aussi du coût du transfert de données entre eux.
L'optimisation YOLO ne consiste pas seulement à convertir des formats de fichiers, mais aussi à transformer une IA de pointe en quelque chose qui fonctionne réellement dans le monde réel. Grâce à des techniques telles que la quantification (utilisation de nombres plus petits), l'élagage (suppression des parties inutiles), la fusion d'opérations (combinaison d'étapes) et la gestion intelligente de la mémoire, nous obtenons des améliorations de performances de 10 à 100 fois supérieures tout en conservant la précision.
Ce qui est remarquable ? Il n'existe pas d'optimisation « idéale » universelle. Un serveur cloud à puissance illimitée nécessite des optimisations différentes de celles d'un drone alimenté par batterie. Un téléphone équipé d'une puce IA dédiée nécessite un traitement différent de celui d'un Raspberry Pi. C'est pourquoi Ultralytics autant d'options d'exportation : chacune est optimisée pour différents scénarios.
Toutes les optimisations dont nous avons parlé ont un seul objectif : rendre la vision par ordinateur accessible partout. Que vous développiez une sonnette intelligente, une application pour drone ou un service cloud à grande échelle, nous vous fournissons les outils nécessaires pour que YOLO dans le cadre de vos contraintes.
Lorsque vous exportez un YOLO avec Ultralytics, vous ne vous contentez pas d'enregistrer un fichier. Vous tirez parti d'années de recherche pour rendre les réseaux neuronaux pratiques. Vous transformez un modèle d'IA de pointe en quelque chose qui peut fonctionner sur du matériel réel, avec des contraintes réelles, pour résoudre des problèmes réels.
C'est ce que nous faisons chez Ultralytics. Nous comblons le fossé entre la recherche en IA et son déploiement pratique. Nous rendons la vision par ordinateur fonctionnelle partout, car l'avenir de l'IA ne repose pas seulement sur les meilleurs modèles, mais aussi sur leur utilité dans le monde réel.
