Apprendre ONNX pour le trading - page 13

[MetaQuotes]

Détection d'objets Yolov7, modèle ML.NET onnx

Détection d'objets Yolov7, modèle ML.NET onnx

https://github.com/ptiszai/Object-Detection-yolov7-ML.NET-onnx

[MetaQuotes]

Implémenter Yolo3 en temps réel avec C#

Implémenter Yolo3 en temps réel avec C#

https://github.com/duonghb53/YoloOnCSharpGPU

[MetaQuotes]

Détection de visage à l'aide de C # et OpenCVSharp - Groupe d'utilisateurs pratiques de ML.NET 19/01/2022

Détection de visage à l'aide de C # et OpenCVSharp - Groupe d'utilisateurs pratiques de ML.NET 19/01/2022

Le didacticiel vidéo sur la détection de visage à l'aide d'OpenCVSharp en C# a commencé par la présentation par l'orateur de la bibliothèque OpenCVSharp, une bibliothèque open source pour les tâches de vision par ordinateur, avec un wrapper .NET. La vidéo traite de l'utilisation de différents classificateurs pour la détection, y compris pour les yeux, et de l'importance de l'expérimentation dans la sélection des classificateurs. Le didacticiel a aidé l'auditeur à créer un programme de détection des visages et des yeux à l'aide de webcams, à l'aide d'extraits de code, de Visual Studio et de blocs-notes interactifs .NET. Différents aspects, y compris la façon de superposer des images transparentes et de gérer correctement les objets mats, ont également été élaborés. L'orateur a reconnu la facilité d'utilisation, la rapidité et la compatibilité d'OpenCVSharp avec .NET, mais a également noté le manque d'exemples et un support à long terme incertain.

• 00:00:00 Dans cette section, l'orateur présente le sujet de la détection de visage à l'aide d'OpenCVSharp en C# et donne un bref aperçu de ce qu'est OpenCVSharp, qui est un wrapper .NET pour OpenCV, une bibliothèque open-source pour les tâches de vision par ordinateur. L'orateur discute des différentes fonctionnalités d'OpenCVSharp, y compris la manipulation d'images, la détection de visage et les modèles de reconnaissance faciale. L'orateur note également que bien qu'il n'y ait pas beaucoup d'exemples C# pour OpenCVSharp, il existe de nombreux exemples Python qui peuvent être facilement convertis en C# en raison des similitudes dans les API. L'orateur poursuit ensuite en énumérant quelques exemples de la façon d'effectuer des tâches spécifiques à la fois en Python et en C # à l'aide d'OpenCVSharp.
  
  
• 00:05:00 Dans cette section, l'orateur discute des différentes versions d'OpenCVSharp et de l'importance d'associer des bibliothèques gérées à des bibliothèques de liaison natives. Ils présentent ensuite quelques exemples utilisant Visual Studio Code et des blocs-notes interactifs .NET, chargeant des packages NuGet et utilisant les fichiers XML en cascade pour effectuer la détection des visages. Le code explique comment intégrer les classificateurs en cascade durs et les utiliser pour détecter les visages et dessiner des cadres autour d'eux dans les images.
  
  
• 00:10:00 Dans cette section, le présentateur explique l'importance de gérer et de supprimer correctement les "objets mat" dans OpenCVSharp pour éviter les fuites de mémoire potentielles. Ils montrent comment charger une image source et créer une nouvelle "image grise" vide pour la détection des visages, car le classificateur fonctionne mieux sur les images en noir et blanc. Ils expliquent ensuite comment utiliser "l'histogramme égalisé cb2" pour normaliser la luminosité et le contraste de l'image, ce qui conduit à une meilleure classification en cascade. Le présentateur explique également comment utiliser les exigences de taille minimale pour la détection des visages afin d'éviter les faux positifs et les artefacts. Enfin, ils montrent comment utiliser le "rectangle cv2" pour dessiner une boîte autour des visages détectés et ouvrir une fenêtre pour afficher l'image résultante, la touche de poids étant utilisée comme moyen pour l'utilisateur de fermer la fenêtre.
  
  
• 00:15:00 Dans cette section de la vidéo, l'orateur explique comment il ne s'attend pas à ce qu'une clé de poids entre car il n'en a pas besoin pour afficher une image statique. Cependant, cela entrera davantage en jeu lorsqu'ils regarderont la démo de la webcam. Ils répondent également à une question sur les espaces de noms par défaut et expliquent comment ils vont détecter non seulement le visage, mais aussi les yeux dans le visage. Ils discutent de l'introduction de deux fichiers en cascade - le visage frontal et la cascade des yeux - et comment ils bouclent à travers les rectangles du visage pour essayer de faire une détection supplémentaire des yeux. Ils expliquent le processus impliqué dans la création d'une région d'intérêt (ROI) et le dessin d'un rectangle autour du visage.
  
  
• 00:20:00 Dans cette section, l'instructeur passe par le processus de détection des yeux dans une image de visage à l'aide de cascades imbriquées dans OpenCVSharp. Ils prennent la région d'intérêt du visage précédemment détectée, la convertissent en gris, puis appliquent une cascade imbriquée spécifiquement pour détecter les yeux. Ce faisant, ils sont capables de dessiner des cercles autour des yeux détectés, le point central du cercle étant l'emplacement des yeux détectés. Ils notent que la taille des yeux détectés doit être inférieure à la taille du visage détecté, et par quelques essais et erreurs, ils ajustent les paramètres de la cascade imbriquée pour mieux détecter les yeux dans des visages de tailles différentes. Dans l'ensemble, bien que le processus ne soit pas parfait, il est efficace pour détecter les yeux dans la plupart des cas.
  
  
• 00:25:00 Dans cette section, l'orateur discute des différents classificateurs qui peuvent être utilisés pour la détection de visage et de la nécessité d'expérimenter pour déterminer quel classificateur fonctionne le mieux dans des situations spécifiques. L'orateur reconnaît également qu'il peut y avoir des artefacts dans le processus de détection et suggère d'utiliser la logique pour les supprimer lors de la production du processus. L'orateur passe ensuite à la discussion sur l'utilisation des webcams et sur la façon dont le code de détection des visages et des yeux par webcam est similaire aux exemples précédents, la seule différence étant l'introduction de la capture vidéo et la création d'un objet fenêtre. Enfin, l'importance d'attendre une milliseconde entre les images pour voir si une touche est enfoncée est mise en évidence, car cela affecte considérablement les images par seconde capturées dans la webcam.
  
  
• 00:30:00 Dans cette section, le présentateur démontre la fonctionnalité de détection de visage dans OpenCVSharp à l'aide de C#. Le code capture les données de la webcam et détecte le visage du sujet en plaçant un cadre autour de lui. Le présentateur explique la clé de poids, une caractéristique distinctive d'OpenCVSharp qui doit être incluse pour que la fenêtre affiche une image. Ils répondent ensuite à une question sur le moment où la méthode de la clé de poids est exécutée et décrivent comment elle est utilisée. La section comprend également un exemple d'ajout d'images par seconde au code de capture de données de la webcam. Le présentateur note l'importance d'inclure la clé de poids, car l'oubli peut causer des problèmes, et montre comment détruire toutes les fenêtres dans le code.
  
  
• 00:35:00 Dans cette section, le présentateur explique comment il peut mettre du texte à l'écran et contrôler la couleur à l'aide de C# et OpenCVSharp. Ils expliquent comment ils définissent une couleur pour la boîte autour des visages et des yeux, et définissent une autre couleur appelée couleur fps, qui est rouge si la fréquence d'images est inférieure à 20 images par seconde et verte si elle est supérieure ou égale à 20. Ils démontrer également l'effet du retard dans la clé de poids et comment il affecte les fréquences d'images. Ils mentionnent qu'avec toutes les variables qui entrent en jeu, ils sont heureux s'ils peuvent obtenir 20 images ou plus par seconde, ce qui leur permet d'atteindre leurs objectifs pour le moment.
  
  
• 00:40:00 Dans cette section, le présentateur montre comment superposer des images et explique l'importance d'utiliser IamReadModes inchangé pour conserver l'élément de transparence d'une image. Ils utilisent des lunettes de soleil comme exemple et admettent que le code n'est pas optimisé, car ils n'ont pas eu le temps de tout rendre parfait. Ils trichent également en codant en dur les coordonnées de l'endroit où ils veulent que les lunettes de soleil atterrissent au lieu d'utiliser les coordonnées x et y du rectangle du visage. Le présentateur explique que dans des scénarios réels, il faudrait transmettre les coordonnées x et y à la méthode MakeOverlay pour savoir où placer la superposition. De plus, ils mentionnent la méthode Resize qui devrait être utilisée pour redimensionner l'image de superposition en fonction de la taille du rectangle, mais ce n'est pas nécessaire dans leur exemple de triche.
  
  
• 00:45:00 Dans cette section, l'orateur explique le processus de fusion d'une image superposée transparente sur une image de base. Tout d'abord, l'image de superposition transparente est convertie en RVB tout en préservant le canal transparent. Ensuite, les canaux RVB sont extraits de la superposition d'origine et fusionnés dans une nouvelle carte. Après cela, le canal de transparence est fusionné avec la nouvelle carte en le dupliquant trois fois dans une nouvelle carte appelée "overlay alpha 3 channel" et en effectuant une opération au niveau du bit. Enfin, la région d'intérêt où les lunettes de soleil seront placées est définie, et le rectangle du visage est extrait pour servir de région d'intérêt du visage pour fusionner les lunettes de soleil.
  
  
• 00:50:00 Dans cette section, l'orateur explique brièvement le processus d'ajout de lunettes de soleil à un visage détecté à l'aide d'OpenCVSharp. Ils utilisent des opérations au niveau du bit pour placer les lunettes de soleil sur le visage détecté, maintenir la transparence et replacer le visage à son emplacement d'origine. L'orateur souligne également certains avantages et inconvénients d'OpenCVSharp, tels que sa facilité d'utilisation, sa vitesse et sa compatibilité avec .NET, mais le manque d'exemples et un support à long terme incertain. Le conférencier fournit diverses ressources et encourage les utilisateurs à parrainer le projet OpenCVSharp sur GitHub. Un participant demande si OpenCVSharp peut fonctionner sur un microcontrôleur tel que Raspberry Pi, et l'orateur répond que cela devrait être possible avec la saveur Linux Arm.

[MetaQuotes]

Prédire sur un modèle Custom Vision ONNX avec ML.NET

Prédire sur un modèle Custom Vision ONNX avec ML.NET

Dans cette vidéo YouTube, le présentateur explique comment utiliser ML.NET pour prédire sur un modèle ONNX de vision personnalisée. Cela implique d'exporter le modèle à partir du service de vision personnalisé et de l'importer dans le projet ML.NET. L'implémentation comprend le redimensionnement des images, l'extraction des pixels de l'image, la création d'un contexte de données et d'une liste de données vide pour charger les données d'image, l'utilisation du framework ML.NET pour faire des prédictions sur le modèle et la sortie des résultats. La vidéo montre également comment obtenir le nom de sortie d'un modèle à l'aide d'un outil appelé Neuron et comment obtenir des informations sur la boîte englobante du modèle pour une image de test donnée. Le présentateur montre également comment dessiner un rectangle autour de la boîte englobante et afficher les étiquettes prédites à l'aide de l'API Graphics. La mise en œuvre du modèle ONNX à l'aide de l'API ML.NET et du redimensionnement d'image est soulignée comme la partie la plus importante de la mise en œuvre.

• 00:00:00 Nous utiliserons le framework ML.NET pour prédire sur un modèle ONNX de vision personnalisée. Pour ce faire, nous devons d'abord exporter le modèle du service de vision personnalisé et l'importer dans notre projet ML.NET. Une fois le modèle dans notre projet, nous pouvons créer un pipeline qui redimensionne les images et extrait les pixels de l'image avant de faire la prédiction sur le modèle. Pour ce faire, nous devons télécharger et ajouter plusieurs packages NuGet à notre projet, ainsi que créer un nouveau contexte de données et une liste de données vide pour charger les données d'image. Enfin, nous utilisons le framework ML.NET pour faire des prédictions sur le modèle et produire les résultats.
  
  
• 00:05:00 Dans cette section, l'orateur explique comment utiliser un outil appelé Neuron pour obtenir le nom de sortie d'un modèle téléchargé à partir de Custom Vision. Neuron est une petite application de bureau qui fournit des informations sur un modèle, y compris les entrées et les sorties. Une fois le nom de sortie obtenu, il peut être utilisé comme nom de colonne de sortie lors de l'appel de la transformation pour appliquer le modèle. L'orateur montre également comment créer un moteur de prédiction et utiliser des méthodes d'assistance pour obtenir des informations sur la boîte englobante du modèle pour une image de test donnée.
  
  
• 00:10:00 Dans cette section, l'intervenant poursuit la mise en œuvre du modèle de détection d'objets en démontrant comment obtenir les cadres de délimitation, dessiner un rectangle autour et afficher les étiquettes prédites pour les images à l'aide de l'API Graphics. La confiance maximale est obtenue pour obtenir la boîte englobante supérieure où une seule boîte englobante avec la confiance maximale est considérée. Le code utilise également des méthodes d'assistance pour dessiner le rectangle, et la chaîne de la description est renvoyée pour indiquer le pourcentage de confiance. Enfin, l'image de test est enregistrée dans le système de fichiers pour référence future. L'orateur souligne que la plus grande partie de la mise en œuvre est le redimensionnement des images et l'application du modèle ONNX à l'aide de l'API ML.NET.

[MetaQuotes]

Rendre les réseaux de neurones portables avec ONNX

Rendre les réseaux de neurones portables avec ONNX

Dans cette vidéo YouTube, Ron Dagdag explique comment rendre les réseaux de neurones portables avec ONNX, en se concentrant sur le côté inférence de l'apprentissage automatique. ONNX est un framework open source qui permet la portabilité des modèles d'apprentissage automatique sur diverses unités de traitement et appareils. L'orateur discute du processus de conversion des modèles vers ONNX, du déploiement et de l'intégration du modèle avec des applications, et de son utilisation pour le déploiement dans le cloud et en périphérie. Ils montrent également comment charger un modèle ONNX dans Node.js et intégrer des modèles de classification d'images dans des applications Web et mobiles à l'aide d'ONNX Runtime. Les modèles ONNX sont une norme ouverte qui peut être créée à partir de divers frameworks pour être déployée efficacement sur la plate-forme cible.

• 00:00:00 Dans cette section, Ron Dagdag présente le concept de rendre les réseaux de neurones portables via ONNX, en se concentrant sur le côté inférence de l'apprentissage automatique. Il explique le processus typique de programmation par rapport à l'apprentissage automatique et le besoin de données de formation, d'un cadre de formation, d'un modèle et d'un environnement d'exécution d'inférence pour créer des algorithmes. Il mentionne également que l'accent de la présentation sera mis sur le côté inférence, en utilisant ONNX pour incorporer le modèle dans une application.
  
  
• 00:05:00 Dans cette section, l'orateur présente ONNX en tant que cadre permettant la portabilité des modèles d'apprentissage automatique sur diverses unités de traitement telles que les processeurs, les GPU et les FPGA, ainsi que sur différents appareils tels que le cloud ou l'IoT. Ils le comparent à un PDF en ce sens qu'il s'agit d'un format qui peut être consommé n'importe où et qui est open source sur GitHub, ayant recueilli plus de 11 000 étoiles et 200 contributeurs. L'orateur recommande d'utiliser ONNX lorsqu'il s'agit de modèles formés en Python qui doivent être déployés avec d'autres applications ou qui nécessitent une latence d'inférence élevée, comme l'exécution sur des appareils périphériques comme Azure Percept.
  
  
• 00:10:00 Dans cette section, l'orateur discute des scénarios où il devient nécessaire de convertir une application programmée sur un système d'exploitation (OS) ou un matériel spécifique pour s'exécuter sur un système d'exploitation ou un matériel différent. La solution consiste à convertir le programme au format ONNX. ONNX est utilisé lors de l'exécution de modèles créés à partir de différents frameworks et lorsque la formation prend trop de temps. Le conférencier détaille ensuite quatre façons d'obtenir un modèle ONNX, dont le premier est le zoo de modèles ONNX sur GitHub. Vient ensuite un service de vision personnalisé, converti à partir d'un modèle existant et formé à l'aide de l'apprentissage automatique Azure ou de l'apprentissage automatique.
  
  
• 00:15:00 Dans cette section, l'orateur discute du processus de conversion des modèles vers ONNX. Le processus n'est pas limité aux modèles écrits en Python et peut également être effectué avec ML.NET. L'orateur montre comment convertir un modèle ML.NET, puis l'enregistrer sur ONNX. Il existe de nombreux modèles disponibles qui ont été convertis en ONNX, notamment des modèles de classification d'images et de détection d'objets. Custom Vision Service peut également être utilisé pour télécharger des images et les étiqueter pour classer différents types d'objets. GitHub fournit une application appelée Netron qui permet aux ingénieurs logiciels de visualiser à quoi ressemble un modèle ONNX, y compris ses entrées et sorties. Le conférencier explique que l'on peut également générer un modèle ONNX en le convertissant depuis PyTorch ou TensorFlow.
  
  
• 00:20:00 Dans cette section, le conférencier montre comment générer un modèle de régression et l'exporter vers ONNX, un format open-source qui permet la portabilité lors de l'utilisation de différents frameworks d'apprentissage automatique. À l'aide de C # et ml.net, l'orateur charge les données salariales dans un cadre de données et forme un modèle de régression, en spécifiant la colonne d'étiquette et l'entrée (années d'expérience) à l'aide d'un pipeline. Après avoir évalué le modèle, ils le convertissent en ONNX en transmettant le modèle, les données d'échantillon et le flux au contexte, ce qui donne un fichier qui peut être visualisé à l'aide de Netron. L'orateur note qu'ONNX peut également être utilisé comme format intermédiaire pour convertir des modèles d'apprentissage automatique entre des frameworks, tels que PyTorch et TensorFlow.
  
  
• 00:25:00 Dans cette section, l'orateur aborde le processus de déploiement et d'intégration d'un modèle ONNX dans une application. La conversion de modèles en ONNX permet une compatibilité entre différents frameworks, et les utilisateurs peuvent également utiliser des modèles ONNX pour l'apprentissage par transfert et le réglage fin. L'orateur souligne l'importance de la gestion des versions et d'avoir un registre de modèles, tout comme un registre de conteneurs, pour un suivi et un déploiement faciles. De plus, l'orateur met en évidence les différents ensembles de compétences requis pour les scientifiques des données qui construisent la "recette" par rapport à ceux nécessaires aux ingénieurs qui démarrent une "boulangerie" et intègrent l'IA dans les applications. L'exposé couvre divers cadres et plates-formes qui prennent en charge le déploiement de modèles ONNX, tels qu'Azure Machine Learning, Ubuntu ou Windows Server, et les appareils de périphérie IoT.
  
  
• 00:30:00 Dans cette section, le conférencier discute du déploiement de modèles d'apprentissage automatique, couvrant à la fois le déploiement dans le cloud et en périphérie. Selon l'orateur, le déploiement en périphérie concerne la proximité du traitement des données avec les utilisateurs, et il est beaucoup plus proche que le cloud. L'exécution de l'IA en périphérie est idéale pour une faible latence et des économies de coûts, car elle peut traiter les données localement sans les télécharger dans le cloud. De plus, l'exécution locale est plus flexible et peut garantir le respect de la confidentialité, ce qui est particulièrement important lorsqu'il s'agit de règles interdisant le partage d'images en dehors du réseau. Pour faciliter le déploiement de modèles d'apprentissage automatique à la périphérie, Microsoft a développé un environnement d'exécution ONNX open source qui prend en charge non seulement les réseaux de neurones, mais également les spécifications d'apprentissage automatique traditionnelles, peut effectuer des inférences hautes performances et possède une architecture extensible pour les accélérateurs matériels.
  
  
• 00:35:00 Dans cette section, le conférencier explique comment rendre les réseaux de neurones portables avec ONNX. Le runtime ONNX permet aux utilisateurs d'exécuter des modèles sur différentes unités de traitement, y compris les GPU, les CPU et les VPU, et il peut être utilisé sur diverses plates-formes, telles que Windows, les navigateurs Web, Node.js et les applications React Native. L'orateur montre une démo sur la façon de charger un modèle ONNX dans une application Node.js et comment transmettre les valeurs d'entrée pour recevoir la sortie souhaitée. En utilisant le runtime ONNX, les développeurs peuvent facilement intégrer des modèles d'apprentissage automatique dans leurs applications sans se soucier de la compatibilité matérielle.
  
  
• 00:40:00 Dans cette section, la vidéo présente ONNX Runtime Web, une bibliothèque JavaScript conçue pour exécuter des modèles ONNX directement dans un navigateur à l'aide des technologies WebAssembly et WebGL optimisées. Cette méthode d'inférence dans le navigateur est plus rapide, plus sûre et moins chère tout en permettant une utilisation hors ligne. Cependant, cela peut ne pas être efficace pour les modèles plus grands qui nécessitent des spécifications matérielles spécifiques et peuvent entraîner des temps de téléchargement plus longs. La vidéo fournit un exemple d'utilisation du Web ONNX Runtime pour analyser une image d'un bébé qui pleure, démontrant comment le modèle est intégré dans un fichier HTML et exécuté à l'aide du moteur d'exécution.
  
  
• 00:45:00 Dans cette section de la vidéo, le présentateur montre comment utiliser le zoo modèle ONNX et le Web d'exécution ONNX pour intégrer un modèle de classification d'images dans une application Web. Il télécharge une image sur l'application Web, la redimensionne et la convertit en niveaux de gris et en un tenseur pour la préparer au modèle pré-formé. À l'aide du Web d'exécution ONNX, le modèle est chargé et alimenté l'image traitée, ce qui donne une prédiction de l'émotion exprimée dans l'image. Le présentateur démontre ensuite la notation d'un modèle ONNX pré-formé dans une application React Native.
  
  
• 00:50:00 Dans cette section, le conférencier discute de l'utilisation d'ONNX runtime mobile en tant que solution d'inférence légère pour exécuter des modèles ONNX optimisés sur les plates-formes Android et iOS. Pour intégrer ONNX runtime mobile dans l'application, on peut utiliser npm install ONNX runtime react native, qui minimise la taille binaire à un modèle ONNX pré-optimisé appelé format ort. Le didacticiel disponible sur onnxruntime.ai explique étape par étape comment déployer des modèles ONNX à l'aide de diverses plates-formes telles que nœud, navigateur Web, réaction mobile, etc. Le tableau de compatibilité montre que Chrome prend en charge l'assemblage Web et WebGL sur Windows 10, macOS, Ubuntu , iOS et Androïd. Les modèles ONNX sont une norme ouverte qui peut être créée à partir de divers frameworks pour être déployée efficacement à l'aide des bons outils sur la plate-forme cible.

[MetaQuotes]

Sur .NET Live - AI Everywhere : Azure ML et ONNX Runtime

Sur .NET Live - AI Everywhere : Azure ML et ONNX Runtime

La vidéo « On .NET Live - AI Everywhere : Azure ML et ONNX Runtime » se concentre sur l'utilisation d'Azure ML et ONNX Runtime pour l'apprentissage automatique avec C#. Les conférenciers discutent des avantages de l'utilisation du format ONNX pour l'exportation de modèles à travers les langages de programmation, de l'optimisation du runtime ONNX pour l'accélération matérielle et l'inférence, et de sa compatibilité avec des versions spécifiques du framework. Ils montrent également comment utiliser ONNX Runtime avec Azure ML dans Python et .NET, créer et former un modèle de réseau neuronal et expliquer l'inférence et sa dernière étape dans l'apprentissage automatique. La vidéo se termine par l'introduction d'un nouveau fournisseur pour le runtime ONNX qui permet l'utilisation d'OpenVINO pour le processeur ARM, offrant des capacités de débogage.

Dans cette section de la vidéo, les hôtes discutent de la flexibilité et de la configurabilité du runtime ONNX et de sa capacité à fonctionner sur diverses plates-formes matérielles et logicielles. Le runtime ONNX est considéré comme un excellent wrapper pour différentes plates-formes, car les clients peuvent l'utiliser sur un cloud, Android, iOS ou le processeur Snapdragon, et il permet une inférence plus rapide.

• 00:00:00 Dans cette section, les hôtes présentent l'invité, Maro Benici, un développeur .NET italien avec une expérience en intelligence artificielle (IA). L'épisode se concentrera sur la façon d'utiliser Azure ML et ONNX Runtime avec C # pour continuer à étudier l'apprentissage automatique. Dans le segment de bits associé, ils discutent d'un document sur le site Azure Machine Learning sur la réalisation de prédictions avec des modèles AutoML ONNX dans .NET, qui est étroitement lié au sujet du jour.
  
  
• 00:05:00 Dans cette section, l'intervenant discute de la possibilité d'exporter des modèles d'apprentissage automatique au format ONNX pour partager des modèles entre des frameworks à l'aide de composants dans Automl dans Azure Machine Learning. Pour effectuer une inférence dans .NET, le package d'exécution ONNX est utilisé, ml.net exécutant le pipeline de prédiction à l'aide du modèle ONNX. Netron, un outil pour comprendre les entrées et les sorties d'un modèle est présenté, et la création de classes pour les entrées et les sorties est démontrée. Enfin, le pipeline comprenant le modèle est défini et une instance d'entrée est exécutée dans le moteur pour effectuer des prédictions, la sortie résultante étant le tarif prévu. L'orateur présente ensuite brièvement un article connexe sur l'utilisation du runtime ONNX avec Stable Difussion pour générer des images AI.
  
  
• 00:10:00 Dans cette section, le conférencier explique comment la technologie a évolué au cours des 15 dernières années, du matériel personnalisé aux centres de données et au cloud computing. Il donne un exemple de son premier projet en 2006, qui impliquait des capteurs faits à la main pour capturer les minéraux dans un vignoble, et comment les données étaient stockées sur des disques durs portables et expédiées à un laboratoire pour être analysées. Aujourd'hui, le même projet pourrait être réalisé avec un téléphone mobile, avec des données collectées sur le cloud et analysées en temps réel, permettant d'effectuer des alertes et des ajustements instantanés. L'orateur explique également comment le passage au cloud a ouvert des opportunités pour les entreprises, avec des services basés sur le cloud désormais disponibles pour les clients qui étaient auparavant limités à l'informatique sur site.
  
  
• 00:15:00 Dans cette section, l'orateur aborde les défis auxquels sont confrontés les clients qui utilisent différents langages de programmation pour créer et déployer leurs modèles d'apprentissage automatique. Il explique que le format ONNX a été créé comme une solution à ce problème, permettant aux clients de sauvegarder leurs modèles dans un langage qui peut être rechargé dans un langage de programmation différent. Il poursuit en expliquant qu'ONNX peut exporter les fonctions mathématiques et les valeurs des couches dans le réseau de neurones, permettant une conversion facile entre différentes langues. L'orateur souligne qu'ONNX est utilisé par de nombreuses entreprises, ce qui permet d'externaliser le code et d'utiliser différentes entreprises qui connaissent différents langages de programmation.
  
  
• 00:20:00 Dans cette section, la vidéo traite du framework ONNX et de son utilisation pour l'exportation et l'exécution de modèles d'apprentissage automatique sur différentes plates-formes et langages de programmation. Le framework ONNX permet aux utilisateurs d'exporter des modèles et de les exécuter sans avoir à recharger des bibliothèques ou des frameworks, ce qui facilite la tâche des clients qui ne connaissent peut-être pas Python et TensorFlow. Le runtime ONNX est open source et disponible sur GitHub, et les utilisateurs peuvent sélectionner leur langage et leur architecture préférés pour exécuter le modèle. La vidéo aborde également la compatibilité de l'ensemble d'opérations et la manière dont elle est influencée, car il est essentiel d'assurer la compatibilité avec des versions spécifiques du framework.
  
  
• 00:25:00 Dans cette section, les conférenciers expliquent comment s'assurer que les fonctions mathématiques utilisées dans les modèles d'IA sont compatibles avec la bibliothèque d'exécution ONNX. Ils recommandent d'utiliser la version la plus récente de la bibliothèque, qui prend en charge toutes les opérations du modèle. Ils mentionnent également qu'il existe une mise à jour récente de la documentation ONNX qui offre une meilleure visibilité sur les applications prises en charge et celles qui ne le sont pas. Si une fonction mathématique n'est pas prise en charge, une alerte est générée et l'utilisateur est informé du décalage qui n'est pas pris en charge. Les conférenciers discutent également des avantages de la bibliothèque d'exécution ONNX, tels que l'accélération matérielle pour les GPU et l'optimisation pour les modèles d'IA.
  
  
• 00:30:00 Dans cette section, le conférencier discute de l'optimisation pour l'exécution ONNX et de la possibilité de l'utiliser à la fois pour la formation et l'inférence. Avec ONNX, on peut optimiser le processus de formation et adapter le matériel personnalisé sans repartir de zéro. L'orateur confirme également que le runtime ONNX peut être utilisé pour optimiser le matériel de formation, tandis qu'un autre matériel peut être choisi pour l'inférence. Dans l'ensemble, le conférencier insiste sur la capacité de créer et de former des modèles pour n'importe quel environnement matériel et sur la flexibilité de l'environnement d'exécution ONNX.
  
  
• 00:35:00 Dans cette section, le conférencier parle de l'utilisation d'Azure ML et d'ONNX Runtime pour créer un réseau de neurones pour classer les fleurs. Ils commencent par sélectionner l'application exécutée à l'intérieur d'une machine S11 standard pour la mesure. Ensuite, ils utilisent Tensorflow comme leur entreprise l'utilise généralement et choisissent pandas, NumPy et d'autres outils de prétraitement. Ils discutent du codage des chaînes sous forme de matrices et de la répartition de l'ensemble de données entre la formation et les tests. Ils créent enfin le réseau de neurones, qu'ils encodent au format ONNX afin qu'il puisse être utilisé dans le centre de données de leur client.
  
  
• 00:40:00 Dans cette section de la vidéo, l'intervenant explique le processus de formation d'un modèle de réseau neuronal à l'aide d'Azure Machine Learning et de TensorFlow. Il montre comment compiler le modèle et optimiser la précision avant d'évaluer les performances du modèle. Une fois le modèle formé, il montre comment importer le modèle dans TensorFlow pour créer un nouveau modèle pour le client. Pour faciliter la tâche du client, il définit la spécification d'entrée et nomme l'entrée et la sortie. Il explique également les avantages de convertir le modèle au format ONNX pour le tester avant de le livrer au client.
  
  
• 00:45:00 Dans cette section de la vidéo, le conférencier explique comment utiliser ONNX Runtime avec Azure ML sur Python et .NET. Ils importent ONNX une fois dans Python, sélectionnent un fournisseur et chargent le runtime ONNX à utiliser tout en ignorant le modèle TensorFlow. Ils créent une entrée et l'alimentent avec des valeurs de tableau avant d'exécuter le modèle pour obtenir la sortie. De plus, le conférencier montre comment créer un point de terminaison pour exposer ONNX directement sur Azure et comment utiliser ONNX sur un appareil IoT ou un smartphone à l'aide d'une application console sur .NET Core.
  
  
• 00:50:00 Dans cette section, les hôtes expliquent le concept d'inférence, qui est la dernière étape de l'apprentissage automatique où le réseau neuronal formé est utilisé pour prédire les résultats en fonction de nouvelles données qu'il n'a jamais vues auparavant. Ils discutent également du format ONNX, qui peut convertir n'importe quel modèle de tenseur personnalisé dans un format pris en charge par le runtime ONNX. Ils mentionnent que le pré et le post-traitement du modèle peuvent également être sérialisés dans le modèle ONNX lui-même, ce qui facilite son exécution sur chaque plate-forme. Les hôtes démontrent que le processus est similaire dans différentes langues une fois le modèle chargé.
  
  
• 00:55:00 Dans cette section, l'orateur discute du nouveau fournisseur qui est arrivé pour le runtime ONNX, permettant d'utiliser OpenVINO pour le processeur ARM, permettant le débogage. L'orateur en souligne la puissance, déclarant que lorsque le modèle est pris en charge et peut être exécuté, il n'est pas nécessaire de modifier le code et il est possible d'exécuter le même modèle sans le convertir constamment. L'orateur note que bien que le choix du matériel pour le modèle soit essentiel, ce n'est pas quelque chose que le runtime ONNX contrôle, et les décisions prises lors de l'opérationnalisation du modèle doivent tenir compte des exigences matérielles. De plus, l'orateur mentionne qu'il est possible d'utiliser le runtime ONNX sur un cluster, et en inférence, le modèle n'a pas besoin d'être converti à chaque fois.

[MetaQuotes]

Berlin Buzzwords 2019 : Lester Solbakken – Mise à l'échelle de l'évaluation des modèles ONNX et TensorFlow dans la recherche

Berlin Buzzwords 2019 : Lester Solbakken – Mise à l'échelle de l'évaluation des modèles ONNX et TensorFlow dans la recherche

Lester Solbakken discute des défis de la mise à l'échelle de l'apprentissage automatique pour les applications de recherche et propose une solution alternative à l'utilisation de serveurs de modèles externes. Il suggère d'évaluer les modèles d'apprentissage automatique sur les nœuds de contenu, plutôt que d'envoyer des données à des serveurs de modèles externes, pour améliorer l'évolutivité et contrôler la latence et le débit. Solbakken met en évidence l'utilisation par Vespa de son propre langage de classement et de son extension d'API tenseur pour faciliter la création d'un package déclaratif d'état pour une application, ainsi que l'effort continu pour prendre en charge les modèles d'apprentissage automatique dans Vespa. Il souligne l'importance de comprendre la corrélation entre les différentes phases de classement pour éviter les problèmes de récupération au niveau du système et encourage les gens à contribuer au projet open source.

• 00:00:00 Dans cette section de la vidéo, Lester Solbakken aborde les défis de la mise à l'échelle de la production d'apprentissage automatique spécifiquement pour les applications basées sur la recherche. Il explique comment les serveurs de modèles sont devenus de plus en plus populaires pour résoudre les problèmes de performances et d'évolutivité, mais pour les applications de recherche, l'évaluation du modèle pour chacun des résultats de recherche conduit rapidement à un goulot d'étranglement de la capacité du réseau. La solution consiste soit à envoyer moins de données pour les résultats, soit à trouver un moyen d'évaluer le modèle localement pour chaque serveur. Solbakken évoque le travail de son équipe avec la plateforme de recherche Vespa pour résoudre ces problèmes.
  
  
• 00:05:00 Dans cette section, Lester Solbakken aborde le défi de la mise à l'échelle de l'évaluation des modèles ONNX et TensorFlow pour la recherche. Une solution potentielle consiste à envoyer des fonctionnalités aux serveurs de modèles, mais le problème est que les serveurs de contenu et de modèles peuvent évaluer le classement en fonction de différents ensembles de fonctionnalités, ce qui peut réduire la probabilité d'obtenir les meilleurs résultats à l'échelle mondiale. Au lieu de cela, Solbakken suggère d'évaluer les modèles sur les serveurs de contenu pour obtenir de meilleurs résultats, ce qui a été travaillé chez Vespa. Vespa, qui est largement utilisé pour des centaines de milliers de requêtes par seconde dans le monde entier avec des centaines de publications américaines en cours d'exécution, possède de riches fonctionnalités de base, notamment l'élasticité, l'évolutivité et la capacité de notation pertinente avancée.
  
  
• 00:10:00 Dans cette section, Lester Solbakken explique comment Vespa intègre ONNX et TensorFlow pour faciliter la création d'un package déclaratif d'état pour une application, facilitant ainsi l'utilisation de modèles d'apprentissage automatique. Vespa utilise son propre langage de classement pour exécuter ces modèles, et l'extension API tenseur fournit un petit ensemble de fonctionnalités de base qui peuvent représenter différents types de calcul. L'avantage est que différents modèles provenant de différentes sources peuvent être traduits dans ce format, ce qui facilite leur optimisation. Solbakken met également en évidence une référence qu'ils ont mise en place pour tester l'hypothèse selon laquelle l'envoi de données n'est pas efficace, émulant un système de recommandation de blog où ils ont utilisé un produit scalaire dans la première phase et un réseau de neurones dans la deuxième phase.
  
  
• 00:15:00 Dans cette section, l'orateur discute des limites d'évolutivité des serveurs de modèles externes pour l'apprentissage automatique dans la recherche et propose une solution alternative. Il explique que l'ajout de nœuds de contenu supplémentaires pour répartir la charge de travail peut améliorer la latence et suggère qu'en faisant en sorte que ces nœuds réécrivent un plus grand nombre de documents, vous pouvez augmenter le nombre de résultats avec des modèles d'apprentissage automatique, ce qui entraînera des résultats de qualité potentiellement supérieure. Grâce au classement en plusieurs phases, où l'évaluation est effectuée sur le nœud de contenu et pas seulement sur un réseau, il est possible d'adapter et de contrôler la latence et le débit. L'orateur conclut que les serveurs de modèles externes ne sont pas une bonne solution pour la mise à l'échelle et souligne l'importance d'évaluer plutôt sur le nœud de contenu.
  
  
• 00:20:00 Dans cette section, Lester Solbakken parle du classement multiphase dans Vespa et de l'importance de comprendre la corrélation entre les différentes phases pour éviter les problèmes de récupération au niveau du système. Il mentionne également que la prise en charge des modèles dans l'apprentissage automatique et Vespa est un effort continu et encourage les gens à contribuer au projet open source. Pour ceux qui souhaitent jouer avec Vespa, ils peuvent trouver de nombreuses ressources sur la page d'accueil Vespa AI, y compris des exemples d'applications, des cas d'utilisation et des didacticiels.

[MetaQuotes]

Assimiler ONNX

Assimiler ONNX

Dans cette vidéo, le présentateur présente ONNX en tant que norme ouverte pour l'interopérabilité de l'apprentissage automatique qui peut fonctionner sur toutes les plateformes. Ils passent par le processus de création d'un projet ONNX à partir de zéro, en peaufinant un exemple du repo Microsoft, en résolvant les problèmes et en explorant d'autres projets Github liés à ONNX. Ils testent ensuite une liaison ONNX à l'aide de GPT2 et CUDA, exprimant leur intérêt à explorer plus avant les liaisons Rust d'exécution ONNX à l'avenir. Le présentateur note la polyvalence et la portabilité d'ONNX et y voit un bon outil d'expérimentation et de construction de projets plus conséquents à l'avenir.

• 00:00:00 Dans cette section, le conférencier présente ONNX , une norme ouverte pour l'interopérabilité de l'apprentissage automatique qui permet l'utilisation de nombreux frameworks et accélérateurs différents pour l'inférence sur les services cloud. Ils mentionnent la disponibilité d'un wrapper sécurisé autour de l'environnement d'exécution ONNX avec un accélérateur d'inférence et de formation ML haute performance multiplateforme. Ils mettent également en évidence la portabilité associée à ONNX , car il peut fonctionner sur toutes les plates-formes différentes, et montrent comment créer un nouveau projet ONNX à partir de zéro en utilisant des exemples de Microsoft Branch. L'orateur note qu'ONNX étant activement travaillé et continuellement intégré, il fournit un bon outil pour jouer avec l'apprentissage automatique.
  
  
• 00:05:00 Dans cette section de la vidéo, le présentateur accède au site Web ONNX pour obtenir la dernière version et créer un environnement d'exécution ONNX. Ils montrent également comment copier et modifier un exemple du repo Microsoft et ajouter un makefile. De plus, ils intègrent l'abonné de traçage et gbt dans le code et ajoutent le modèle squeeze net. Le présentateur rencontre quelques erreurs mais les résout en vérifiant un exemple précédent et en s'assurant que les modèles corrects sont disponibles.
  
  
• 00:10:00 Dans cette section, l'orateur résout un problème où il essaie d'utiliser une version spécifique d'ONNX, mais rencontre des erreurs. Ils essaient différentes méthodes pour résoudre le problème, telles que la copie d'un exemple de travail et la reconstruction du projet, mais aucune d'entre elles ne semble fonctionner. Finalement, ils trouvent un exemple plus ancien dans la documentation ONNX qui fonctionne avec la version souhaitée. Ils échangent le modèle et sont capables de compiler et d'exécuter le programme avec succès. Dans l'ensemble, cette section souligne l'importance de vérifier soigneusement les dépendances et d'être prêt à essayer différentes solutions lors du débogage.
  
  
• 00:15:00 Dans cette section de la vidéo, l'orateur discute des limites de l'exemple ONNX de base "Hello world" et suggère qu'il serait plus utile d'avoir un exemple qui charge et manipule une image. Ils mettent en évidence d'autres projets Github liés à ONNX, tels que Rust Code Search et Track ONNX , qui ont des fonctionnalités plus avancées, et montrent leur intérêt à les essayer. De plus, ils explorent le projet GPT-RS, qui permet l'utilisation de modèles GPT2 avec CUDA, et expliquent comment il pourrait potentiellement être utilisé pour manipuler des données d'image.
  
  
• 00:20:00 Dans cette section, l'utilisateur teste une liaison ONNX à l'aide de GPT2 et CUDA, qui génère des sorties de test pour l'achèvement du code ou l'achèvement du texte. L'utilisateur trouve cet exemple prometteur et exprime son intérêt à explorer davantage les liaisons Rust d'exécution ONNX à l'avenir. Ils résument leur expérience comme une expérience intéressante et expriment le désir de construire quelque chose de plus substantiel lors de leur prochaine tentative avec ONNX.

[MetaQuotes]

HITNET Vs. Comparaison de l'estimation de profondeur stéréo neurale ACVNet (ONNX)

HITNET Vs. Comparaison de l'estimation de profondeur stéréo neurale ACVNet (ONNX)

Comparaison des modèles d'estimation de profondeur stéréo HITNET et ACVNet dans l'ensemble de données Driving Stereo.

Détails de l'inférence du modèle (NVIDIA 1660 SUPER) :
HITNET (640X480) : 220 ms
ACVNet (640x384) : 480 ms
Références : [Inférence HITNET] https://github.com/ibaiGorordo/ONNX-HITNET-Stereo-Depth-estimation
[Inférence ACVNet] https://github.com/ibaiGorordo/ONNX-ACVNet-Stereo-Depth-Estimation
[Ensemble de données de conduite stéréo] https://drivingstereo-dataset.github.io/

[MetaQuotes]

Importez, formez et optimisez des modèles ONNX avec NVIDIA TAO Toolkit

Importez, formez et optimisez des modèles ONNX avec NVIDIA TAO Toolkit

La vidéo montre comment utiliser le kit d'outils NVIDIA TAO pour importer, former et optimiser des modèles ONNX. Il commence par télécharger un modèle ResNet18 pré-formé, en l'ajustant avec TAO sur l'ensemble de données Pascal VOC, et fournit des étapes pour importer le modèle et visualiser le graphique ONNX. La progression de la formation peut être surveillée à l'aide de la visualisation TensorBoard, et des couches personnalisées peuvent être utilisées en cas d'erreurs de conversion ONNX. La vidéo explique également comment évaluer les performances du modèle en observant la perte décroissante, en validant la perte et en analysant les poids et les biais. Les utilisateurs peuvent évaluer la précision du modèle sur l'ensemble de données de test et des exemples d'images et poursuivre l'élagage et l'optimisation pour l'améliorer davantage.

• 00:00:00 Dans cette section, la vidéo explique comment importer, former et optimiser des modèles ONNX à l'aide de NVIDIA TAO Toolkit. La vidéo commence par télécharger un modèle ResNet18 pré-formé, qui est ensuite affiné sur l'ensemble de données Pascal VOC à l'aide de TAO. Les étapes d'importation du modèle ONNX et de visualisation du graphique ONNX sont également abordées. De plus, la vidéo explique comment surveiller la progression de la tâche de formation à l'aide de la visualisation TensorBoard. Enfin, la vidéo mentionne que TAO peut gérer des couches personnalisées et fournit des conseils sur la façon de les utiliser pour importer des modèles qui ne parviennent pas à se convertir.
  
  
• 00:05:00 Dans cette section, l'orateur explique comment évaluer les performances du modèle formé. Les utilisateurs peuvent regarder la perte décroissante pour s'assurer que le modèle s'améliore. De plus, la perte de validation peut aider à identifier le surajustement. Les utilisateurs plus avancés peuvent afficher des graphiques et des histogrammes pour comprendre les poids et les biais du modèle. L'orateur montre comment vérifier la précision globale du modèle sur l'ensemble de données de test et comment évaluer les performances du modèle sur des exemples d'images. Le modèle peut encore être amélioré et les utilisateurs peuvent poursuivre l'élagage et l'optimisation du modèle pour améliorer encore la précision.