Ce billet se propose d'aborder ce domaine prometteur au travers du sujet de la classification d'images comme son titre l'indique.

Nous vous proposons de voir cela de plus prêt au travers d'une illustration. Je tiens à remercier Xiangzhe Meng actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Qu'est-ce que le Transfer Learning ?

Ainsi, le Transfer Learning peut se traduire dans la pratique comme une approche puissante qui permet aux utilisateurs de créer rapidement des modèles d'apprentissage profond (Deep Learning) en apprenant à partir de réseaux de neurones pré-entraînés avec de grands ensembles de données.

Autrement dit, nous utilisons un modèle déjà bien entraîné et l'adaptons à notre propre problème. Notre nouveau modèle est pour l'essentiel basé sur les caractéristiques et les concepts appris lors de l'entraînement du modèle de base.

Avec un réseau de neurones convolutifs (CNN), nous utilisons les caractéristiques apprises à partir d'un ensemble des données qui est suffisamment grand, par exemple ImageNet qui contient 1,2 million d'images avec 1000 catégories, et retirons la dernière couche de classification en la remplaçant par une nouvelle couche dense prédisant les étiquettes de classe de notre nouveau domaine.

Pourquoi le Transfer Learning ?

Le Transfer Learning s'avère une technique utile lorsque nous devons classifier certaines images dans différentes catégories, mais que nous ne disposons pas de suffisamment de données pour entraîner un réseau de neurones profonds (DNN) à partir de rien.

En effet, l'entraînement des DNNs nécessite beaucoup de données, toutes étiquetées. Cependant, nous ne disposons pas toujours de ce type de données. Si notre problème est similaire à celui pour lequel un réseau de neurones a déjà été entraîné, nous pouvons utiliser le Transfer Learning pour modifier ce réseau de neurones en fonction de notre problème avec une fraction des images étiquetées nécessaire : nous parlons maintenant de dizaines au lieu de milliers des images.

Il convient de souligner, qu'au-delà de la reconnaissance d'images qui sera notre illustration dans la suite de ce billet, le Transfer Learning est également utilisé avec succès pour adapter les modèles de réseau de neurones existants à la traduction, à la synthèse de la parole et à de nombreux autres domaines. Le Transfer Learning est ainsi notamment utilisé dans la cybersécurité comme en témoigne la session « Transfer Learning: Repurposing ML Algorithms from Different Domains to Cloud Defense » de Mark Russinovich, Directeur technique Azure, lors la dernière conférence RSA en avril dernier.

Comment fonctionne Transfer Learning ?

La figure ci-dessous illustre le principe du Transfer Learning. Le modèle de l'étudiant est initialisé en copiant les N-1 premières couches de l'enseignant. Une nouvelle couche dense est ajoutée pour la classification. Sa taille correspond au nombre de classes dans la tâche d'étudiant. Le modèle de l'étudiant est ensuite entraîné en utilisant son propre jeu de données, tandis que les K premières couches sont « gelées », c'est-à-dire que leurs poids sont fixes et que seuls les poids des N-K couches sont mis à jour.

Les K premières couches sont « gelées » au cours de l'entraînement, parce que les sorties de ces couches représentent déjà des caractéristiques significatives pour la tâche de l'étudiant. Le modèle de l'étudiant peut réutiliser directement ces caractéristiques ; ce qui peut réduire à la fois les coûts de l'entraînement et la quantité de données requises.

En fonction du nombre de couches gelées (K) pendant le processus de l'entraînement, le Transfer Learning est classifié dans les trois types suivants :

• Extracteur de caractéristiques de couches profondes (Deep-layer Feature Extractor) :

  N-1 couches sont gelées pendant l'entraînement du modèle de l'étudiant et seule la dernière couche de classification est mise à jour. Ceci est préférable lorsque la tâche de l'étudiant est très similaire à la tâche de l'enseignant et qu'elle nécessite un coût de l'entraînement minimal.

• Extracteur de caractéristiques de couche intermédiaire (Mid-layer Feature Extractor) :

  Les K premières couches sont gelées, où K < N -1. En général, l'extracteur de caractéristiques de couche intermédiaire se montre plus performant que l'extracteur de caractéristiques de couches profondes dans les scénarios où la tâche de l'étudiant diffère plus de la tâche de l'enseignant et où plus de données d'apprentissage sont disponibles. En permettant à plus de couches d'être mises à jour, l'étudiant optimisera mieux sa propre tâche.

• Extracteur de caractéristiques de réglage (Full Model Fine-tuning) :

  Toutes les couches sont dégelées et ajustées pendant l'entraînement du modèle de l'étudiant (K = 0). Cela nécessite beaucoup plus de données d'apprentissage et est approprié lorsque la tâche de l'étudiant diffère de manière significative de la tâche de l'enseignant.

En général, l'entraînement avec les poids de modèle de l'enseignant permet au modèle de l'étudiant de converger plus rapidement et d'obtenir potentiellement de meilleures performances que d'entraîner à partir de zéro.

L'outillage

Aujourd'hui, de plus en plus de plates-formes de Machine Learning et de bibliothèques de Deep LeEarning commencent à recommander le Transfer Learning à leurs utilisateurs. Beaucoup d'entre elles proposent à cet effet des tutoriels détaillés pour guider les utilisateurs dans le processus de Transfer Learning.

C'est en particulier le cas de notre bibliothèque Microsoft Cognitive Toolkit (CNTK), une bibliothèque de Deep Learning open source déjà abordée sur ce même blog que nous utiliserons dans la suite de ce billet pour notre illustration et pour construire notre modèle de Transfer Learning.

Le tutoriel « Build your own image classifier using Transfer Learning » de CNTK décrit une tâche de classification des fleurs et recommande le modèle ResNet_18 comme le modèle de base et « Full Model Fine-tuning » comme la configuration par défaut.

CNTK fournit également des paramètres de contrôle pour passer en mode « Deep-layer Feature Extractor ». Cependant, le mode « Mid-layer Feature Extractor » n'est pas (encore) disponible à ce stade.

En termes d'outillage, d'aucun pourrait également citer PyTorch ou d'autres bibliothèques encore.

Notre illustration

Le but de notre illustration consiste à créer un pipeline de classification d'images avec le Transfer Learning. Ainsi, nous nous proposons de construire un modèle de Transfer Learning pour classifier les images de cinq sortes de fruits : pomme, banane, raisin, orange, fraise.

Nous allons pour cela suivre les 8 étapes ci-dessous :

1. Créer des dossiers en respectant une structure spécifique.
2. Obtenir des données (images) (optionnel).
3. Télécharger et consulter les modèles de base.
4. Définir les paramètres généraux et choisir le type de Transfer Learning à utiliser.
5. Entraîner le modèle.
6. Évaluer le modèle avec une seule image.
7. Évaluer le modèle avec un groupe d'images.
8. Afficher les images mal-classifiées.

Voyons ce qu'il en est dans le détail.

Le code source et le pipeline complet sont disponibles dans un Jupyter Notebook ici. Vous disposez ainsi de tous les éléments nécessaires pour reproduire ce qui suit ;-)

1. Créer des dossiers en respectant une structure spécifique

Afin de réutiliser le pipeline de classification d'images proposé, vous devez commencer par créer des dossiers selon une structure spécifique et placer nos données (images) dans les dossiers correspondants.

L'approche proposée dans le cahier Jupyter Notebook vise à créer ces dossiers automatiquement. Il reste simplement à définir le nom du jeu de données et des classes différentes pour la tâche.

Voici la structure de dossiers utilisée ainsi pour ce pipeline de classification d'images :

2. Obtenir des données (images) (optionnel)

Cette seconde étape est une étape optionnelle.

Si nous voulons essayer ce pipeline de classification d'images sans cible spécifique, il est possible de simplement définir le nombre total d'images à télécharger et la partition des images pour chaque classe. Ensuite, il suffit de lancer le programme de téléchargement, qui téléchargera automatiquement les images à partir de la bibliothèque Google Image sur GitHub, séparera ces images de manière aléatoire en deux groupes (ensemble des données d'apprentissage et de test) et les stockera dans les dossiers correspondants précédemment créés.

Remarque : Les mots-clés de recherche que nous utilisons pour télécharger des images à partir de Google sont les noms de classe définis dans la partie précédente. Dans notre cas, les mots-clés de recherche sont donc pomme, banane, raisin, orange, fraise.

Voici un exemple de l'exécution pour télécharger les images :

3. Télécharger et consulter les modèles de base

Avant d'entraîner notre modèle de Transfer Learning, nous devons télécharger le modèle de base que nous nous proposons d'utiliser et choisir les couches que nous allons conserver en inspectant la structure des réseaux de neurones.

4. Définir les paramètres généraux et choisir le type de Transfer Learning à utiliser

Avant d'exécuter notre programme de l'entraînement, il est nécessaire de :

1. Définir les paramètres généraux liés au processus d'apprentissage, aux propriétés de l'image d'entrée, et aux emplacements et caractéristiques du modèle et des données.
2. Choisir les types de Transfer Learning.

CNTK supporte à date les modes « Deep-layer Feature Extractor » et « Full Model Fine-tuning » comme évoqué précédemment. Nous devons donc choisir l'un de ces deux modes :

5. Entraîner le modèle

Pour cette illustration, nous avons choisi ResNet_18 comme le modèle de base.

Ce modèle sera adapté à l'aide du Transfer Learning pour la classification des fruits. Ce modèle est un réseau de neurones convolutifs (CNN) construit à l'aide de techniques de réseau résiduel. Les réseaux de neurones convolutifs construisent des couches de convolutions, transforment une image d'entrée et la distillent jusqu'à ce qu'ils commencent à reconnaître les caractéristiques composites. Avec des couches de convolutions plus profondes, ils peuvent même reconnaître des caractéristiques complexes.

Le réseau résiduel est une technique issue de Microsoft Research (MSR). Il consiste à passer par le signal principal des données d'entrée, de sorte que le réseau finisse par apprendre uniquement sur les portions résiduelles qui diffèrent d'une couche à l'autre. Dans la pratique, cela permet d'entraîner des réseaux beaucoup plus profonds en évitant les problèmes qui entravent la descente de gradient sur des réseaux plus vastes. Ces cellules contournent les couches de convolution et reviennent plus tard avant ReLU.

6. Évaluer le modèle avec une seule image

Nous avons deux façons d'évaluer notre modèle. Tout d'abord, nous l'évaluons avec une image choisie et montrons la prédiction avec les probabilités de chaque classe comme ci-dessous.

7. Évaluer le modèle avec un groupe d'images

Après avoir collecté toutes les images de test, nous pouvons également évaluer notre modèle avec toutes ces images une par une, placer la prédiction avec les probabilités de chaque classe dans une table et calculer la précision de la classification.

8. Afficher les images mal-classifiées

Après avoir évalué les modèles avec l'ensemble des données de test, nous pouvons afficher toutes les prédictions erronées afin de trouver une raison potentielle concernant la classification erronée de ces images.

Dans notre cas, par exemple, l'image ci-dessous est mal classifiée car les formes de pomme et d'orange sont assez similaires et ils peuvent avoir la même couleur (verte). C'est peut-être une des raisons pour lesquelles cette image orange est reconnue comme une pomme.

En guise de conclusion

Le Transfer Learning est une approche puissante. Cependant, il a aussi des limites.

Par exemple, nous avons ré-entraîné un modèle qui avait été entraîné sur les images de ImageNet. Cela signifie qu'il connaissait déjà les images et avait une bonne idée des concepts allant du niveau bas (rayures, cercles etc.) au niveau élevé (les petits points sur la surface de fraise etc.).

Ré-entraîner un tel modèle pour classifier les fruits a du sens, mais le ré-entraîner pour détecter les véhicules à partir d'images aériennes serait plus difficile. Nous pouvons toujours utiliser le Transfer Learning dans ces cas, mais il vaut mieux de réutiliser juste les couches précédentes du modèle, c'est-à-dire les couches convolutifs qui ont appris des concepts plus primitifs. Nous aurons donc probablement besoin de beaucoup plus de données d'apprentissage.

Nous l'évoquions dans un précédent billet sur ce même blog, le Service Azure Machine Learning peut effectuer le prétraitement des données, la sélection d'algorithmes et l'optimisation intelligente des hyperparamètres de manière automatisée avec la version préliminaire d'AutoML (Automated Machine Learning).

L'idée derrière ce composant AutoML est simple à comprendre et complexe à implémenter. Ceci nous renvoie à la publication de recherche Probabilistic Matrix Factorization for Automated Machine Learning sur arXiv.org.

AutoML construit pour vous des modèles de Machine Learning de haute qualité en automatisant le modèle et la sélection des hyperparamètres.

Apportez un ensemble de données étiquetées pour lequel vous souhaitez créer un modèle, AutoML vous donnera alors un modèle de Machine Learning de haute qualité que vous pouvez utiliser pour les prédictions.

Si vous êtes nouveau en Data Science, AutoML vous aidera à démarrer en simplifiant la construction de modèle de Machine Learning. AutoML vous soustrait de la nécessité d'effectuer la sélection du modèle, de celle des hyperparamètres et en une seule étape crée un modèle de haute qualité dûment entrainé pour vous prêt à être utilisé.

Si vous êtes un data scientist expérimenté, AutoML vous aide à augmenter votre productivité en effectuant intelligemment pour vous la sélection du modèle et des hyperparamètres pour votre entrainement et génère des modèles de haute qualité beaucoup plus rapidement qu'en spécifiant manuellement plusieurs combinaisons des paramètres et en exécutant des jobs d'entrainement. AutoML fournit la visibilité et l'accès à tous les jobs d'entrainement ainsi qu'aux caractéristiques de performance des modèles pour vous aider à affiner le pipeline si vous le désirez.

Nous vous proposons de voir cela de plus prêt au travers d'une illustration à l'occasion de ce billet.

Je tiens à remercier Xiangzhe Meng actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Cadre et déroulé de l'illustration

Comme mentionné ci-avant, cette illustration a pour but de montrer comment utiliser la technique AutoML afin de trouver le meilleur modèle en fonction de notre critère.

Nous réutilisons ici pour cela le jeu de données « New York City Taxi Trip Duration » du billet précédent pour dérouler notre illustration avec un bénéfice à la clé : la capacité de pouvoir comparer le résultat avec celui généré par notre propre modèle dans la précédente illustration. Ceci nous permettra donc d'évaluer concrètement les performances de cette technique au-delà de ce qui décrit en introduction ;-)

Le notebook Train an automated machine learning model.ipynb contient toutes les procédures qu'il est nécessaire de suivre pour entraîner un modèle en utilisant la technique AutoML.

Nous pouvons entraîner le modèle non seulement en local mais aussi avec une machine virtuelle Science des données (ou DSVM pour Data Science Virtual Machine) distante.

Une fois le meilleur modèle trouvé, nous pouvons le déployer en suivant les mêmes procédures que celles présentées dans le billet précédent via le notebook Deploy models.ipynb.

A l'issue de l'ensemble de ces opérations, nous observons que le résultat obtenu avec AutoML est conforme à l'attente ! sic, en nous mettant à disposition un meilleur modèle que celui généré lors de la précédente illustration (Light GBM Regressor avec la corrélation de Spearman 0,711, ce qui est plus élevée que celle du modèle entraîné par nous-mêmes : Linear Regressor 0,683).

Ainsi, une telle technique peut être utilisée à notre avis pour valider les modèles déjà sélectionnés et optimisés par nous-même. De plus, nous pouvons même obtenir un meilleur modèle que nous n'avions pas envisagé avant de tester avec cette technique.

Pour aller plus loin

Nous espérons que cette illustration vous aura donné envie d'approfondir le sujet.

A ce propos, il nous parait pertinent de (re-)mentionner le billet Release models at pace using Microsoft's automated machine learning! ainsi que les trois liens suivants dans la documentation en ligne :

1. Didacticiel : Entraînement d'un modèle de classification par Machine Learning automatisé dans le service Azure Machine Learning.
2. Classe AutoMLConfig. Cette classe est utilisée dans le but de soumettre une expérimentation AutoML au service Azure Machine Learning. Cet objet contient tous les paramètres de configuration ainsi que les données à utiliser lors de l'exécution.
3. Optimiser les hyperparamètres pour votre modèle.

Autre point à souligner, vous trouverez au sein de la collection de notebooks Machine Learning mise à disposition sur le repo Azure/MachineLearningNotebooks sur la forge GitHub toute une série de proposition sur AutoML ici.

Nous souhaitons enfin conclure ce billet en mentionnant la disponibilité du toolkit NNI (Neural Network Intelligence) sur GitHub, un toolkit en open-source pour l'AutoML qui correspond à un autre investissement de Microsoft dans le domaine très populaire aujourd'hui de l'AutoML.

Cette illustration s'appuie sans surprise sur des notebooks Jupyter ; ce que rendent justement possible ces nouveaux SDKS comme cela a été souligné.

Je tiens à remercier Xiangzhe Meng actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Cadre de l'illustration

L'exemple retenu pour les besoins de cette illustration correspond dans la pratique directement au projet de la compétition « New York City Taxi Trip Duration » organisé par Kaggle il y a un peu plus d'un an.

Le but du projet consistait à prévoir la durée de chaque trajet en fonction de ses attributs propres ; ce à quoi nous allons nous atteler.

Avant cela, arrêtons-nous un instant sur le jeu de données utilisé.

Description des données

Le jeu de données a été publié à l'origine par la NYC Taxi and Limousine Commission (TLC).

Celui-ci est composé de 1458644 lignes et 11 colonnes. Chaque ligne représente un enregistrement de trajet.

Un enregistrement contient 11 informations concernant un trajet donné comme suit :

• id – Identifiant du trajet
• vendor_id – Identifiant de la compagnie de taxi
• pickup_datetime - Date et heure auxquelles le compteur a été engagé
• dropoff_datetime - Date et heure auxquelles le compteur a été désengagé
• passenger_count – Nombre de voyageur dans le taxi
• pickup_longitude - Longitude où le compteur a été engagé
• pickup_latitude - Latitude où le compteur a été engagé
• dropoff_longitude - Longitude où le compteur a été désengagé
• dropoff_latitude - Latitude où le compteur a été dégagé
• store_and_fwd_flag - Drapeau pour indiquer si cet enregistrement a déjà été enregistré dans le mémoire du taxi avant d'envoyer à la compagnie de taxi : Y = oui, N = non
• trip_duration – Durée du trajet

Prérequis technique pour cette illustration

De façon à pouvoir reproduire l'illustration, il est nécessaire au préalable d'avoir réalisé les opérations suivantes :

1. Créer un compte Azure. Si vous ne disposez pas d'un compte Azure, il vous est possible de créer un compte gratuit Azure ici.
2. Créer un espace de travail Azure Machine Learning comme décrit ici. Pour mémoire, un espace de travail est le conteneur logique de tous vos actifs, ainsi que la limite de sécurité et de partage.

   Une fois que vous avez créé un espace de travail, vous pouvez accéder à un ensemble riche de capacités via les SDKs en Python. C'est justement l'objet du point suivant.

3. Configurer un environnement de développement et installer les SDKs d'Azure Machine Learning. Vous pouvez les installer avec une simple commande pip install, ou de préférence au sein d'un environnement virtuel Conda isolé.

Deux environnements de développement sont recommandés :

• Jupyter Notebook en local sur votre ordinateur. Jupyter notebook est devenu l'un des outils les plus populaires pour la science des données ou data science en raison de de sa nature auto-documentée et de son interactivité.

  Si vous souhaitez utiliser Jupyter notebook en local sur votre ordinateur, il est recommandé d'utiliser Anaconda pour isoler votre environnement de travail afin d'éviter les conflits de dépendance entre les packages.

  Le tutoriel ici vous permet pour configurer Jupyter Notebook sur votre propre ordinateur.

  Remarque : Si la version de Conda est inférieure ou égale à 4.4, il faut utiliser activate <nom_env> pour activer le nouvel environnement et deactivate <nom_env> pour le désactiver.

  Pour installer le SDK de préparation des données d'Azure Machine Learning en Python, il faudra utiliser la commande suivante :

pip install - -upgrade azureml-dataprep

• Azure Notebooks dans Azure. Azure Notebooks est un service Jupyter Notebook dans le cloud Azure. Azure Notebooks est préconfiguré pour fonctionner avec le Service Azure Machine Learning.

  Les composants requis, tels que les SDK d'Azure Machine Learning en Python, sont préinstallés sur cet environnement. On peut donc utiliser directement Azure Notebooks comme l'environnement de développement sans avoir besoin de la configuration.

L'objet de l'illustration et le jeu de donnée étant introduit, et l'environnement d'exécution pour les SDKs d'Azure Machine Learning à priori en place ou supposé comme tel, venons-en à notre flux de travail de Machine Learning à proprement parler, avec deux grands temps :

• La nécessaire préparation des données.
• L'entraînement et le déploiement du modèle.

De façon à nous inscrire directement dans la philosophie de ces SDKs que nous souhaitons illustrer, nous nous sommes directement appuyés sur différentes bloc-notes ou notebooks Jupyter.

Il vous sera d'autant plus facile de reproduire l'illustration de bout-en-bout ! ;-)

Tous ces notebooks Jupyter sont directement accessibles depuis un repo GitHub créé pour la circonstance : https://github.com/xiangzhemeng/Demo-Azure-Machine-Learning-SDKs

Préparation des données

Le notebook Data preparation.ipynb contient tous les pré-traitements et les « feature engineerings » que l'on réalise avec les données « brutes ».

Comme vous pouvez le constater au travers des codes et des descriptions associées, nous utilisons ici le SDK de préparation des données d'Azure Machine Learning en Python principalement pour charger et transformer les données.

Cependant, pour le côté visualisation des données, nous nous reposons plutôt sur d'autres bibliothèques, comme par exemple Matplotlib, Seaborn et Folium, comme le SDK de préparation des données d'Azure Machine Learning ne fournit pas la fonctionnalité de visualisation de données, du moins pour le moment.

En même temps, la nouvelle philosophie adoptée prend ici tout son sens en tirant parti pleinement de l'écosystème Python.

Entraînement et déploiement du modèle

Pour entraîner le modèle avec le service Azure Machine Learning, il est nécessaire, dans un premier temps, de créer un fichier de configuration d'espace de travail avec le notebook Create workspace config file.ipynb et de récupérer les données à partir du Stockage Azure avec le notebook Download Data from Azure Storage.ipynb.

Remarque : Le Stockage Azure est un service fournissant un stockage en cloud qui est hautement sécurisé, durable, et évolutif. Azure Storage inclut Azure Blobs (objets), Azure Data Lake Storage Gen2, Fichiers Azure, etc. Dans notre cas, on utilise Azure Blobs pour stocker les données. L'Azure Blob est la solution de stockage d'objets pour le Cloud. Le stockage d'objets blob est optimisé pour stocker des quantités énormes de données non structurées.

Remarque : Si le volume des données n'est pas très grand, on n'a pas vraiment besoin d'utiliser le Stockage Azure. On peut directement les charger à partir de notre propre ordinateur.

Nous entrainons dans un second temps le modèle avec deux types de machines virtuelles :

• Entraînement avec des machines virtuelles Science des données (ou DSVM pour Data Science Virtual Machine) via le notebook Train models with DSVM.ipynb.

  Les DSVMs sont des images de machines virtuelles pre-installées, configurée et testées pour les travaux de Data Science. Ces machines virtuelles comprennent des outils, des IDEs et des packages populaires tels que Jupyter Notebook, PyCharm et Tensorflow.

  Les composants requis pour notre illustration, tels que les SDKs d'Azure Machine Learning en Python, sont également préinstallés sur cet environnement.

• Entraînement avec un « cluster » de machines virtuelles à priorité basse via le notebook Train models with Batch.ipynb.

  Azure Batch propose des machines virtuelles à faible priorité pour réduire le coût des charges de travail par lots. Les machines virtuelles à faible priorité permettent de nouveaux types de charges de travail par lots en utilisant une grande quantité de puissance de calcul à un coût très bas. Les machines virtuelles à faible priorité tirent parti de la surcapacité dans Azure.

  Le « trade-off » pour utiliser des machines virtuelles à faible priorité est que ces machines peuvent ne pas être disponibles pour être alloués ou peuvent être préemptés à tout moment, en fonction de la capacité disponible.

Enfin, en dernier lieu, nous utilisons le notebook Deploy models.ipynb pour déployer le modèle sous la forme d'un service web.

Un web service est une image, dans notre cas une image Docker, qui encapsule la logique de « scoring » et le modèle lui-même.

En guise de conclusion

Nous espérons que cette illustration vous aura permis de découvrir les nouveaux SDKs d'Azure Machine Learning récemment introduits et donné envie d'aller plus loin avec pour vos flux de travail de Machine Learning.

A ce propos, nous souhaitons mentionner un autre repo GitHub crée par l'équipe Azure Machine Learning au sein du Support Premier de Microsoft : https://github.com/Azure/AMLSamples

Vous y trouverez toute une série de cas d'usages qui vous permettront d'approfondir votre connaissance et la maitrise de ces SDKs.

Dernier point et non des moindres à ce propos, ce repo est destiné à :

• Être alimenté avec diverses illustrations en fonction des demandes reçues au niveau de support.
• Recevoir les notebooks Jupyter mis à jour pour l'article Maintenance prédictive pour scénarios réels.

L'objectif, vous l'aurez compris, est aussi de vous faciliter le cas échéant la migration de vos contenu Workbench vers ces niveaux SDKs d'Azure Machine Learning en Python.

Le Service Azure Machine Learning - qui a fait l'objet de toute une série de billets sur ce blog depuis le lancement de sa version préliminaire publique en septembre 2017 à l'occasion de la précédente édition de cette même conférence Ignite - n'y fait pas exception et continue d'évoluer :-) pour toujours mieux répondre à l'attente des scientifiques des données ou data scientists. La section § 2.1.3 « New Azure Machine Learning capabilities » du livret précédent lui est dédiée.

Si, au chapitre de de ces évolutions, nous trouvons de nouvelles mises à jour importantes du service qui incluent :

• le Machine Learning automatisé afin d'identifier les algorithmes les plus efficaces et optimiser les performances du modèle,
• dans le même registre, l'optimisation intelligente des hyperparamètres,
• des modèles supplémentaires bénéficiant d'une accélération matérielle pour les FPGAs (Field-Programmable Gate Arrays) pour des scénarios de reconnaissance et de classification d'images à très haute vitesse et à faible coût,

Nous avons souhaité mettre l'accent l'espace de ce billet – comme son titre l'indique – sur les nouveaux kits de développements (SDKs) en Python qui rendent ainsi le Service Azure Machine Learning accessible à partir des environnements de développement intégrés (IDEs) et autres notebooks populaires de Python.

Une question se pose alors de prime abord : Qu'advient-il de l'application Azure Machine Learning Workbench ?

À propos d'Azure Machine Learning Workbench…

Dans la pratique, si les fonctions principales d'Azure Machine Learning allant des expérimentations au déploiement du modèle n'ont pas fondamentalement changé è à certains ajouts près, l'application Azure Machine Learning Workbench et certaines autres fonctionnalités antérieures se trouvent désormais dépréciées dans la version de septembre 2018.

Cette évolution vise à améliorer au final l'architecture d'Azure Machine Learning et les flux de travail associés comme décrits dans l'article Architecture and concepts: How does Azure Machine Learning service work?.

Les SDKs que nous allons aborder tout de suite après ainsi qu'une nouvelle extension Azure CLI (Command Line Interface) pour le Machine Learning permettent d'accomplir concrètement toutes nos tâches de Machine Learning et pipelines qu'il était possible de réaliser au travers de l'application Azure Machine Learning Workbench.

Si l'on revient un instant sur les récentes innovations en matière de Machine Learning, la plupart d'entre elles se produisent dans la sphère du langage Python. C'est pourquoi Microsoft a fait le choix d'exposer les fonctionnalités clé du service via un SDK Python et de façon à pouvoir bénéficier pleinement de tout l'écosystème associé.

Pour plus d'informations, vous pouvez consulter l'article What is happening to Workbench in Azure Machine Learning (preview)?

Si vous avez installé l'application Azure Machine Learning Workbench (et/ou que créé des comptes d'expérimentation et de gestion de modèles), vous pouvez par ailleurs vous reporter à l'article Migrate to the latest version of Azure Machine Learning service afin de migrer vers cette version la plus récente.

Ce nécessaire « point de situation » étant partagé, il est désormais temps de passer aux nouveaux SDKs d'Azure Machine Learning ;-)

SDK principal d'Azure Machine Learning SDK en Python

Le SDK principal d'Azure Machine Learning en Python est destiné à être utilisé par les data scientists et les développeurs d'IA afin de créer et exécuter des flux de travail de Machine Learning avec Azure Machine Learning.

Il s'agit concrètement de pouvoir rapidement construire, entraîner et déployer vos modèles de Machine Learning et de Deep Learning pour différents domaines.

Pour cela, ce SDK comprend dans la pratique un ensemble de packages, avec à la clé différents modules et classes dont vous pouvez tirer parti pour vos flux de travail de Machine Learning :

• azureml-core
• azureml-train-core
• azureml-train-widgets
• azureml-pipeline-core
• azureml-pipeline-steps
• azureml-train-automl
• azureml-telemetry
• azureml_webservice-schema

Comme le souligne Eric Boyd, Corporate Vice President, AI Platform, qui a dirigé cette « ré-imagination » du Service Azure Machine Learning :

"We heard users wanted to use any tool they wanted, they wanted to use any framework, and so we re-thought about how we should deliver Azure Machine Learning to those users. We have come back with a Python SDK that lights up a number of different features."

Ces fonctionnalités comprennent notamment l'apprentissage profond distribué (Distributed Deep Learning), qui permet aux développeurs de construire et d'entrainer des modèles plus rapidement avec des clusters de GPUs (Graphical Processing Units), et d'avoir l'accès aux FPGAs pour l'image scénarios de reconnaissance et de classification à haute vitesse évoqués en introduction sur Azure.

Comme évoqué précédemment, vous pouvez interagir avec ce SDK depuis n'importe quel environnement Python, y compris Jupyter notebook comme avec Azure Notebooks, un service gratuit qui peut être utilisé pour développer et exécuter du code dans un navigateur utilisant Jupyter, ou d'autres IDEs de Python, à l'image de PyCharm, de Visual Studio Code, ou encore d'Azure Databricks et ses notebooks.

Pour plus Visual Studio Code d'informations, vous pouvez consulter l'article What is the Azure Machine Learning SDK for Python?

SDK de préparation des données d'Azure Machine Learning

Comme nous avons pu l'illustrer sur ce blog, la préparation des données constitue une part importante d'un flux de travail de Machine Learning. Vos modèles seront plus précis et efficaces s'ils ont accès à des données propres dont le format est facile à utiliser.

Le SDK de préparation des données d'Azure Machine Learning en Python permet de charger des données dans différents formats, de les transformer pour être plus facilement utilisable et d'écrire ces données à un emplacement afin que vos flux de travail de Machine Learning et vos modèles dans ce contexte puissent y accéder.

A l'instar du SDK précédent, vous pouvez interagir avec ce SDK depuis n'importe quel environnement Python.

Le SDK de préparation des données d'Azure Machine Learning présente certains avantages par rapport à d'autres bibliothèques populaires dans le domaine de la préparation des données, comme par exemple la bibliothèque d'analyse de données Pandas :

• La lecture intelligente. Le SDK peut détecter automatiquement tous les types de fichiers pris en charge. On n'a donc pas besoin d'utiliser de lecteurs de fichiers spéciaux pour CSV, texte, Excel, etc., ni de spécifier des paramètres de délimiteur, d'en-tête ou de codage.
• Le passage à l'échelle en streaming. Plutôt que de charger toutes les données en mémoire, le moteur du SDK fournit les données en continu ; ce qui lui permet de s'adapter et de mieux fonctionner sur les grands volumes de données.
• Une fonctionnalité multi-plateforme avec un script de code unique. Votre code Python est écrit sur la base d'un seul SDK et vous pouvez l'exécuter sous Linux, MacOs, Spark ou Windows avec une évolutivité verticale (mode « scale-up ») ou horizontale (mode « scale-out »). Lors de l'exécution en mode « scale-up », le moteur tente d'utiliser tous les threads matériels disponibles. Lorsqu'il exécute en mode « scale-out », il permet au planificateur distribué d'optimiser l'exécution.

Pour plus d'informations, vous pouvez consulter les articles suivants :

• What is the Azure Machine Learning Data Prep SDK for Python?
• Load and read data with Azure Machine Learning
• Transform data with the Azure Machine Learning Data Prep SDK
• Write data using the Azure Machine Learning Data Prep SDK

Ces articles vous donneront une bonne compréhension de l'API ainsi mise à disposition par le SDK de préparation des données d'Azure Machine Learning en Python.

Pour ce qui est d'une référence API à proprement parlé, la documentation des différents modules du package azureml-dataprep ici.

La présentation de certaines évolutions clé du service Azure Machine Learning étant désormais chose faite avec en point principal la disponibilité de nouveaux SDKs d'Azure Machine Learning en Python, nous vous proposons d'aborder dans la seconde partie de ce billet une illustration concrète de ceux-ci au travers de la réalisation d'un flux de travail complet de Machine Learning avec le Service Azure Machine Learning.

Dans l'actualité récente, citons en particulier :

• D'abord ONNX (Open Neural Network Exchange), un format open source de modèles de Machine Learning et de réseau de neurones, développé par Microsoft en coopération avec notamment Facebook et Amazon.
• Ensuite ML.NET, un Framework de Machine Learning à part entière qui permet de simplement créer ses propres modèles dans un environnement .NET.
• Et finalement Windows ML, une plateforme pour les applications Windows qui permet d'y apporter des fonctionnalités de Machine Learning.

Vous pouvez vous renseigner plus en détail sur ces outils en consultant les différents billets qui leur sont dédiés sur ce même blog (ONNX, ML.NET et Windows ML).

Au-delà de leurs capacités intrinsèques multiples et en évolution continue, il nous semble important de mettre en perspective les possibilités offertes par une utilisation conjointe de ces outils ; d'où l'idée de profiter de l'espace de ce billet pour présenter un exemple possible d'utilisation de ces outils ensembles.

Je tiens à remercier Pierre Lataillade actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Une petite démonstration

Comme évoqué ci-avant, l'idée même de cet exemple consiste à illustrer et suivre l'emboitement naturel de chacun de ces outils afin de créer un exemple cohérent et auto-suffisant.

Cette succession naturelle peut se traduire comme suit :

1. Commencer par d'abord entrainer un modèle de Machine Learning sur ML.NET,
2. Puis l'exporter sous format ONNX.
3. Et enfin l'utiliser dans une application UWP grâce à la plateforme Windows ML.

Le code source de cet exemple est disponible sur GitHub sur ce repo.

L'utilisation finale de cet exemple est la suivante : on veut pouvoir utiliser une application UWP pour reconnaitre des chiffres manuscrits qui y sont dessinés.

La capture d'écran ci-dessous donne une idée de l'application de cet exemple.

Pour arriver à ce résultat, nous allons donc utiliser les outils mentionnés précédemment.

Chez ML.NET

Commençons par le début et donc un programme utilisant ML.NET pour entrainer un modèle de Machine Learning à reconnaitre des chiffres manuscrits.

Pour l'entrainer, nous nous somme basé sur le jeu de donnés classique : MNIST.

Celui-ci a été modifié pour être facilement traitable par un Framework de Machine Learning et peut se trouver sous la forme de deux fichiers dans le dossier mldotnetMNIST : train.csv et test.csv.

Dans cette partie du projet, nous allons procéder en trois étapes pour aboutir à notre résultat désiré, à savoir un modèle de Machine Learning adapté entrainé sur notre jeu de donnés.

Il s'agit en premier lieu de définir le format d'entrée et de sortie de notre modèle pour pouvoir correctement y lier les données.

C'est l'objet des classes contenues dans le fichier MNISTData.cs.

Ensuite, lorsque l'on lance le programme principal, il convient de créer le pipeline d'apprentissage en utilisant les formats définis ci-dessus, de charger les données d'entrainement et de les lier à notre pipeline d'apprentissage.

Ici, pour les besoins de l'illustration, notre pipeline d'apprentissage est composé de deux étapes : i) l'analyse d'un fichier d'entrée pour en extraire nos données sous le format d'entrée voulu, puis ii) un classifieur multi-classes de régression logistique.

Il s'agit d'un classifieur classique dont on sait qu'il est adapté aux problèmes de reconnaissances de caractères (et donc notamment de chiffres) manuscrits.

Finalement, on lance l'apprentissage et on exporte le modèle dans le format ONNX voulu. Et voilà !

Les deux premières étapes de notre exemple sont ainsi couvertes.

On peut alors effectuer des mesures de test et de validation sur notre modèle pour déterminer si on en est satisfait du résultat.

Ce qui nous donne ces résultats a priori satisfaisants :

Du côté de Windows ML

Il est temps de passer à la troisième et dernière étape de notre exemple.

Pour pouvoir maintenant utiliser le modèle ONNX de Machine Learning ainsi produit dans une application UWP, on s'intéresse naturellement à l'utilisation de la plateforme Windows ML.

Pour les besoins de notre illustration, notre application UWP est dans la pratique une reprise et une modification du code mis à disposition par Microsoft sur ce repo GitHub. Il s'agit comme la capture d'écran précédent le suggère d'une application qui se veut très simple quant à l'utilisation d'un modèle de Machine Learning pré-entrainé pour reconnaitre des chiffres manuscrits dessinés par l'utilisateur.

La solution Visual Studio MNIST_Demo.sln résultante est disponible dans le dossier windowsmlMNIST. (Vous pouvez télécharger gratuitement Visual Studio 2017 Community ici.)

De manière parallèle au cas de ML.NET il s'agit d'abord de définir le format du modèle ainsi que le format de ses entrées et de ses sorties. Comme souligné dans le billet précédent de ce blog, la génération de ces informations s'effectue de manière automatique à partir du modèle ONNX.

Deux opérations sont ensuite nécessaires pour utiliser notre modèle.

Il faut tout d'abord charger le modèle en mémoire. Ceci a lieu au lancement de l'application (fichier MainPage.xaml.cs).

Ensuite, dès que l'on souhaite appliquer le modèle à une donnée, c'est-à-dire, ici, reconnaitre un chiffre manuscrit, il faut lier l'entrée du modèle avec la donnée réelle, ici le contenu d'un canevas), puis appeler la prédiction du modèle.

Ceci nous affiche alors (93% du temps) le bon chiffre manuscrit.

En guise de conclusion

Malgré leurs sorties récentes, ML.NET, ONNX et Windows ML permettent d'ores et déjà de s'agencer entre eux de manière assez intuitive comme nous avons souhaité l'illustrer ici de façon pratique. On arrive alors à produire des résultats satisfaisants à partir d'implémentations somme toute assez minimales.

Avec l'arrivée de nouvelles versions (toujours plus abouties) de ces outils, cette fluidité devrait continuer à s'améliorer, tout en gardant cette simplicité d'implémentation ! :-)

Je tiens à remercier Pierre Lataillade actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Qu'est-ce que Windows ML ?

L'objectif réside dans le cas présent à permettre à tous les développeurs d'applications ou de services Windows de pouvoir utiliser des fonctionnalités d'IA.

Windows ML est une plateforme qui apporte des fonctionnalités d'apprentissage automatique ou Machine Learning à des applications Windows UWP.

Cette dernière permet d'exécuter des modèles de Machine Learning préalablement entrainés, au format ONNX, c.à.d. un format standard de l'industrie, développé par Microsoft, Facebook et Amazon Web Services (AWS) - un billet sur ce blog a été consacré à ONNX -.

Cette vidéo de Channel 9 AI Show vous donne une idée des possibilités ainsi offertes.

(Le code de l'application exemple est disponible via ce billet de blog.)

Windows ML exécute ces modèles de Machine Learning sur la machine Windows locale, et se charge d'exploiter au mieux les capacités de celle-ci.

A ce titre, remarquons cependant que Windows ML n'est pas un Framework de Machine Learning ou Deep Learning (apprentissage profond) comme cette plateforme ne permet pas dans la pratique d'entrainer ou de paramétriser des modèles ; elle permet juste de les utiliser.

D'autres outils Microsoft sont disponibles pour entrainer des modèles de Machine Learning/Deep Learning (tels que le Microsoft Cognitive Toolkit (CNTK) ou ML.NET - un billet sur ce blog a été consacré à ML.NET -.

Windows ML offre une flexibilité de lieu d'exécution qui ne dépend plus uniquement du Cloud (où la plupart des exécutions de modèles de Machine Learning ont (encore) lieu actuellement) : si l'appareil est déconnecté du Cloud ou que les données ne peuvent pas y être envoyées – pour des questions de coût, de taille, de latence par exemple – on peut toujours décider d'effectuer le processus de Machine Learning sur la machine locale.

Ceci s'inscrit pleinement dans la stratégie d'« Intelligent Cloud – Intelligent Edge » de Microsoft.

Quelques fonctionnalités de Windows ML

Windows ML permet de s'abstraire des spécificités système qu'il est généralement nécessaire de prendre en compte lors de l'exploitation de modèles de Machine Learning.

Pour cela, la plateforme se place en couche intermédiaire entre l'application et les sous-couches responsable de gérer les interactions avec les composants physiques du système.

Avec des appareils compatibles, WindowsML exploite les accélérations matérielles possibles (carte graphique, optimisations de processeur, etc.), ainsi que l'optimisation de certains types de donnés (image et vidéo par exemple) afin d'augmenter les performances d'évaluation de modèles de Lachine Learning. Ceci permet d'utiliser des fonctionnalités de Machine Learning dans un environnement où les résultats sont nécessaires en temps réel à l'image des moteurs de jeu.

Du côté du code, Windows ML se charge aussi de générer une interface autour du modèle de Machine Learning, permettant de l'utiliser facilement depuis une application UWP.

Sur Visual Studio 2017 (en version 15.7), cette génération se fait automatiquement.

Dans l'Explorateur de Solution, cliquez sur votre dossier ressource, puis sélectionnez « Ajouter > Elément existant ».

Après avoir choisi votre modèle ONNX (mnist.onnx dans notre illustration), le modèle est ajouté au projet ainsi que le fichier mnist.cs qui contient l'interface automatiquement générée.

On peut également générer ce fichier supplémentaire grâce à l'outil mlgen si on n'utilise pas Visual Studio par exemple.

Cette interface permet d'interagir assez facilement avec les fonctionnalités proposées par les modèles de Machine Learning. Elle suit le patron « Load, Bind and Evaluate », c.à.d. « Charger, Lier et Evaluer » : autrement dit, on commence par charger en mémoire le modèle de Machine Learning à partir d'un fichier sous format ONNX, on lie ensuite les données d'entrée correspondant au type d'entrée attendu, puis on évalue le modèle sur les données d'entrée. Cette dernière étape fournis des résultats qui peuvent être consultés et analysés.

C'est pour cela que 3 classes sont créées dans le fichier automatiquement généré : MNISTModelInput ,MNISTModelOutput et MNISTModel.

La première définit le type attendu en entrée, la seconde celui qui sera donné en sortie, et la troisième s'occupe de charger le modèle, de le lier aux entrées réelles et à la sortie, puis d'exposer une méthode d'évaluation du modèle.

Voilà pour les principes de base !

Commencer avec Windows ML

Avant de commencer, il est nécessaire d'avoir installé le kit de développement Windows 10 SDK et d'utiliser une version de Windows 10 au moins aussi récente que la 17110. Il est par ailleurs recommandé d'utiliser Visual Studio en tant qu'IDE notamment pour la génération automatique d'interface comme nous l'avons illustré.

Cette page présente une prise en main claire de Windows ML basée sur exemple simple préexistant. Cette prise en main permet d'appréhender les outils et méthodes nécessaires pour utiliser WindowsML dans le cadre d'une application UWP simple.

Pour aller plus loin

D'autres projets servant d'exemples sont disponibles sur ce repo GitHub et permettent de voir d'autre cas d'applications de Windows ML.

Il ne vous reste plus qu'à développer vos applications intelligentes ! ;-)

Je tiens à remercier Pierre Lataillade actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Qu'est-ce que ML.NET ?

Annoncé lors de la conférence //Build 2018 en mai dernier, ML.NET est un nouveau Framework d'apprentissage automatique ou Machine Learning créé à destination des développeurs .NET.

Dans la pratique, ce Framework permet donc de créer, paramétriser, tester et intégrer nativement des modèles de Machine Learning personnalisés au sein de ses applications .NET Core. Autrement dit, ML.NET permet ainsi d'analyser des sentiments, de prédire des prix, de détecter des fraudes, etc. dans le contexte spécifique de votre application .NET Core.

ML.NET se positionne en complément des services (ou APIs) cognitifs Cognitive Services et des services Azure Machine Learning (auxquels nous avons consacrés toutes une série de billets sur ce blog) disponibles sur la plateforme Microsoft Azure et ce, en proposant une approche centrée autour du code, permettant de construire son propre modèle et de le déployer localement sur son application.

ML.NET est en open source et multi-plateforme (Windows, Linux et MacOs). ML.NET est amené à rapidement progresser et évoluer pour toujours proposer de nouvelles fonctionnalités et connections avec d'autres solutions.

Mise à jour : A ce propos, ML.NET vient de passer en version 0.3 au mois de juillet dernier.

Pourquoi ML.NET ?

ML.NET était originalement développé en interne au sein de Microsoft Research (MSR) pour être utilisé dans des produits et services Microsoft comme Windows, Bing ou Azure pour n'en citer que quelques-uns. Désormais, avec cette version préliminaire publique, tout un chacun peut utiliser la puissance du Machine Learning pour de la classification, du clustering ou de la régression dans des applications .NET.

Dans les faits, ML.NET reste un Framework simple d'utilisation basé comme beaucoup de Frameworks et de bibliothèques de Machine Learning autour de pipelines d'apprentissage.

A titre d'illustration, l'extrait de code ci-dessous donne une idée de la méthode requise pour créer un modèle de reconnaissance de sentiment et l'entrainer.

var pipeline = new LearningPipeline();

//Pour charger les données sous format texte
pipeline.Add(new TextLoader(dataPath).CreateFrom<SentimentData>(separator: ','));
//Pour passer de format texte à format "numérique" sur lequel l'algorithme peut fonctionner
pipeline.Add(new TextFeaturizer("Features", "SentimentText"));
//Classificateur à proprement parler à entrainer
pipeline.Add(new FastTreeBinaryClassifier());

//Entrainement
var model = pipeline.Train<SentimentData, SentimentPrediction>();

Pour obtenir la prédiction d'un modèle sur une nouvelle donnée, un simple appel de méthode suffit ! :-)

//Générer une donnée à traiter
SentimentData data = new SentimentData
{
SentimentText = "Today is a great day!"
};

//Prédiction du sentiment dans cette donnée
SentimentPrediction prediction = model.Predict(data);

Console.WriteLine("prediction: " + prediction.Sentiment);

Comme mentionné ci-avant, ML.NET est un projet récent et dû à son caractère Open Source, le Framework est amené à grandement évoluer et progresser dans le futur proche, notamment en ajoutant des fonctionnalités et des extensions (vers d'autres Frameworks et plateformes de Machine Learning par exemple).

Les composants disponibles avec la version 0.1 de ML.NET sont les suivants.

La version 0.2 ajoute des capacités de clustering au Framework, ainsi que des améliorations sur les méthodes de validations des modèles (partition entrainement-test, validation croisée, et.) et au-delà dans de nombreux autres domaines. Dans tous ces cas, les composants sont accessibles à partir une API simple et générique qui a pour but de se généraliser aux appels d'autre Frameworks.

Mise à jour : La nouvelle version 0.3 du mois de juillet propose à la clé de nombreuses nouvelles fonctionnalités : tout d'abord la capacité d'exporter certains modèles sous format ONNX pour plus d'inter-compatibilité, mais aussi de nouveau classifieurs (tels le LightGBM) et de nouveaux éléments de transformation (comme la possibilité d'utiliser des méthodes d'ensemble ou des méthodes « Un contre Tous » avec des classifieurs existants).

Nous vous donnons rendez-vous sur les liens suivants pour un récapitulatif plus complet sur l'historique des évolutions apportées :

• ML.NET 0.1
• ML.NET 0.2
• ML.NET 0.3

Comment commencer avec ML.NET ?

Pour se familiariser avec les bases de l'apprentissage automatique, ce lien fournit quelques ressources essentielles.

Pour commencer avec ML.NET, il convient avant tout de s'assurer d'avoir installé .NET Core 2.0 (ou une version plus récente).

Il faut ensuite installer le paquet NuGet ML.NET depuis une ligne de commande :

dotnet add package Microsoft.ML

Quelques didacticiels en anglais sont disponibles dès aujourd'hui pour commencer à se familiariser avec ML.NET.

Il est assez facile de commencer avec la prédiction de pétales d'iris, un exemple classique dans le domaine du Machine Learning qui s'est trouvé repris par quelques billets de ce même blog.

Une liste de tutoriels sur le sujet donne quelques exemples supplémentaires qui permettent de mieux comprendre le fonctionnement de ML.NET sur des cas d'application plus complexes.

Pour aller plus loin

Sur cette page du repo GitHub consacré au projet, d'autre exemples sont (encore) disponibles, allant d'échantillons basiques jusqu'à des applications complètes.

La documentation de ML.NET sur docs.microsoft.com permet aussi de trouver des informations intéressantes sur le sujet.

Si vous êtes intéressés pour faire progresser ML.NET en suggérant de nouvelles fonctionnalités ou en corrigeant des problèmes, n'hésitez pas à vous rendre sur la page GitHub principale du projet.

Enfin, une communauté Gitter active permet d'échanger et d'interroger les membres actifs qui développent et travaillent avec ML.NET pour rester au plus proche des nouveautés et des avantages que proposent le Framework.

Dans ce contexte, nous avons consacré récemment un certain nombre de billets à des services de la plateforme IA de Microsoft à l'image d'Azure Machine Learning et il semblait intéressant de nous arrêter l'espace de ce billet sur un projet moins connu mais pour autant clé, à savoir le projet ONNX, d'où le titre de ce billet.

Je tiens à remercier Pierre Lataillade actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Qu'est-ce qu'ONNX ?

ONNX (Open Neural Network Exchange) est un format en Open Source pour modèles d'apprentissage profond ou Deep Learning.

Annoncé en Septembre 2017 par Microsoft et Facebook, ce projet communautaire sur GitHub vise à établir un écosystème ouvert pour les modèles d'Intelligence Artificielle (IA). Une première version d'ONNX a été publié en Décembre 2017 après une vague de soutient de nombreux acteurs dans le domaine (avec notamment l'arrivée d'Amazon Web Services (AWS)).

Dans ce billet, nous allons tenter d'expliquer et d'exploiter les avantages de ce format. Et commencer par nous intéresser à pourquoi un tel projet ?

Pourquoi ONNX ?

Il existe aujourd'hui de nombreux Frameworks pour créer et déployer des modèles de Deep Learning. On peut ainsi nommer Caffe2, PyTorch, Cognitive Toolkit (CNTK), Apache MXnet, Chainer, TensorFlow, Apple CoreML, Scikit-Learn et d'autres encore existent. Cette liste est donc loin d'être exhaustive.

Tous ces Frameworks possèdent leur propres représentations propriétaires des modèles qu'ils permettent de constituer et qu'ils utilisent. Cependant, jusqu'à présent, aucune de ces représentations ou format n'est réutilisable dans un autre Framework.

De plus, chaque Framework possède intrinsèquement ses spécificités et ses spécialités, dues à leurs méthodes d'accès aux ressources physiques de la machine : exécution efficace en bordure, entrainement rapide, utilisation dans un réseau complexe, etc.

Ces différents avantages et ces contraintes donnent naturellement lieu à des besoins de conversion entre les formats utilisés par les différents modèles. C'est justement notamment pour éviter ces lourdeurs que le projet ONNX existe.

L'idée centrale consiste à pouvoir utiliser les Frameworks que l'on souhaite pour générer, tester, paramétriser ou déployer notre modèle et d'assurer une transition fluide et simple entre les différents Framework utilisés grâce à ONNX.

En effet, le format ONNX issu du projet communautaire éponyme peut être importé et exporté par de nombreux Frameworks.

Vous pouvez à cet effet consulter :

• Ce lien pour une liste à jour des Frameworks totalement supportés,
• Et celui-ci pour ceux qui le sont aussi partiellement, par exemple uniquement en écriture.

Les objectifs de ce format étant établis, regardons les principes de fonctionnement.

Comment fonctionne ONNX ?

Sans rentrer dans les détails – ce billet n'y suffirait pas -, ce format définit dans les grandes lignes un graphe calculatoire extensible, des opérateurs standard, des types de données standard et, facultativement, de la métadonnée sur le modèle (auteur, but, etc.).

Le graphe calculatoire est un graphe acyclique composé des nœuds. Chaque nœud possède au moins une entrée et une sortie et représente un appel à un opérateur.

Ces opérateurs peuvent être soit standard (c.à.d. prédéfinis par ONNX), soit définis de manière externe au modèle. Une fois ces données définies, elles sont sérialisées par le format d'échange de données Protobuf (Protocol Buffers).

Ce format permet de représenter simplement les modèles de Deep Learning et de garantir (notamment grâces aux opérateurs et types de données standard) la transversalité d'ONNX.

Comment commencer avec ONNX ?

Il faut comprendre qu'ONNX n'existe pas seul, et que son utilisation dépend forcément du Framework concerné (même si celle-ci reste toujours très simple). Par exemple, la bibliothèque associée à ONNX, qui permet d'importer et d'exporter des modèles sous ce format, peut être installée par défaut avec le Framework considéré ou peut demander au contraire une installation spécifique.

De plus, il faut avoir préalablement créé un modèle pour (pouvoir) le sauvegarder sous format ONNX.

A titre d'illustration, voici ici un exemple en PyTorch pour montrer la facilité d'utilisation d'ONNX.

Pour que cet exemple en Python fonctionne, il est nécessaire d'avoir installé au préalable le paquet pytorch. On utilisera un modèle préexistant disponible par défaut avec PyTorch : celui d'AlexNet.

Et voilà !

Avec les quelques lignes précédentes, on a ainsi exporté notre modèle AlexNet sous le format ONNX dans le fichier alexnet.onnx.

La simplicité de cette opération se retrouvent avec les autres Framework prenant en charge le format.

Pour l'importation d'un modèle à partir du fichier, une simple ligne de code avec des arguments plutôt faciles à fournir. Cette page redirige vers toutes les informations spécifiques à chaque Framework concerné.

Pour progresser

Pour se faire une idée des utilisations possible d'ONNX, cette partie du repo GitHub d'ONNX donne quelques exemples et tutoriels plus complexes au-delà des principes précédents.

Globalement cependant l'utilisation des fonctionnalités d'ONNX demeure extrêmement simple.

Il peut être intéressant de noter que si vous utilisez Visual Studio, l'extension Visual Studio Tools for AI permet de convertir des modèles sous certains formats (CoreML, TensorFlow, SciKit, LIBSVM et XGboost) vers un format ONNX depuis une interface graphique intégrée à l'EDI à partir d'outils Python spécialisés (dont l'installation est guidée si nécessaire).

Visualiser les modèles ONNX

Il peut être intéressant (notamment lors de travaux collaboratifs) de visualiser les modèles contenus dans les fichiers ONNX.

Pour cela, il existe à ce jour deux outils principaux, mais l'un des deux est beaucoup plus simple d'utilisation et d'installation que l'autre. Nous nous intéressons ici au premier. Vous pouvez suivre ce lien si vous voulez absolument utiliser l'outil plus compliqué -.

Il s'agit du projet communautaire Netron sur GitHub. Netron est un logiciel/d'une application Web à part entière, qui permet de charger notamment des modèles sous forme ONNX afin de les visualiser au sein d'une interface graphique.

Si vous travaillez avec Visual Studio, avec l'extension Visual Studio Tools for AI mentionnée précédemment, Netron est directement disponible depuis l'interface habituelle de l'IDE afon de permettre de visualiser les modèles utilisés

Pour aller plus loin

Ceci conclut cette première introduction au projet ONNX et au format qu'il représente. Nous espèrons que ce billet vous aura donné l'envie de creuser le sujet !

Vous pouvez télécharger l'eBook A Developer's Guide to Building AI Application pour en apprendre plus sur ONNX.

Pour en apprendre plus sur ONNX et, le cas échéant participer à cet effort, rendez-vous sur http://onnx.ai. Vous pouvez également obtenir des mises à jour sur l'actualité d'ONNX via Facebook et @onnxai sur Twitter.

Nous commençons cette nouvelle année 2018 avec ce billet qui s'inscrit dans la série de billets déjà publiés sur les nouveaux services d'Azure Machine Learning (Azure ML). Pour mémoire, cette série de billets vise à vous faire découvrir progressivement ce nouvel environnement Azure ML, à en partager avec vous les nouveautés et bénéfices, et de pouvoir aborder plus en profondeur certains aspects des fonctionnalités ainsi offertes.

Ce billet s'intéresse plus particulièrement comme son titre l'indique à la collaboration en équipe autour d'un projet de Data Science (DS).

L' « établi » dans Azure ML, à savoir Azure ML Workbench, vous permet, entre choses, de collaborer avec votre équipe au travers de l'intégration de Git en arrière-plan, et ainsi de partager vos avancées, l'historique de vos exécutions, etc. Dans la version courante, et à la date de publication de ce billet, Azure ML propose la prise en charge d'un dépôt Git sur Visual Studio Team Services (VSTS) est supporté. (Le support de forges externe comme GitHub est prévu dans les versions à venir pour venir étoffer le champ des possibles.)

Voyons ce qu'il en est et comment collaborer efficacement au travers des fonctionnalités présentes. Bien évidemment, pour cela, vous devez au préalable avoir créé un compte d'Expérimentation sur la plateforme Microsoft Azure comme décrit dans ce billet de la série.

J'en profite pour remercier Paul Jenny actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Créer son projet d'équipe ou utiliser un existant

Pour créer votre projet d'équipe (Team Project), vous devez d'abord vous rendre sur le portail Azure puis Créer une ressource et enfin recherchez Team Project et puis cliquez sur le bouton Créer :

Si vous n'avez pas de compte de service d'équipe (Team Services), vous devez en créer un à ce stade via la fenêtre dédiée comme illustré ci-après :

Choisissez bien GIT en contrôle de version pour votre projet d'équipe ainsi que la localisation appropriée.

Par ailleurs, vérifiez bien de cibler votre projet d'équipe dans le même abonnement Azure que vous allez utiliser pour Azure Machine Learning sinon vous ne pourrez pas accéder à vos projets !

Une fois tout ceci fait, vous pouvez cliquer sur Créer.

Vous pouvez accéder à tout moment aux projets que vous avez créés dans votre compte « Team Services » en accédant à votre espace de la forme :

https://<nom_de_votre_team_services>.visualstudio.com

Par exemple, ici, avec un compte « Team Services » créé sous le nom « myteamazure », nous y accédons par le lien : https://myteamazure.visualstudio.com

Créer un projet Azure ML Workbench lié à Git

Lorsque vous souhaitez créer votre projet Azure ML Workbench ou bien utiliser un projet existant, vous pouvez spécifier l'URL vers le dépôt Git qui sera utilisé pour héberger le projet. Généralement, il est sous la forme suivante :

https://<nom_de_votre_team_services>.visualstudio.com/_git/<nom_du_projet>

Par exemple, ici, le dépôt de notre Git serait :

https://myteamazure.visualstudio.com/_git/myTeamProject

Créer un nouveau projet

Lors de la création d'un nouveau projet dans Azure ML Workbench, il vous est possible de spécifier le l'URL de ce dépôt Git dans Visualstudio.com GIT Repository URL (optional) comme suit vis-à-vis de notre illustration :

Une fois créé, vous pourrez utiliser le projet comme s'il avait été initialisé sans dépôt Git. Néanmoins, si par exemple vous souhaitez utiliser/êtes amené(e) un autre poste de travail, vous pourrez retrouver votre projet Azur eML avec les mêmes fichiers et le même historique d'exécution en téléchargeant celui-ci en utilisant le bouton suivant dans Azure ML Workbench :

Remarque : actuellement lorsque vous téléchargez votre projet sur un second poste de travail, il est téléchargé dans le répertoire suivant :

• Sur Windows, C:\Users\<nom_utilisateur>\Documents\AzureML
• Sur MacOS, /home/<nom_utilisateur>/Documents/AzureML

Nous souhaitons souligner ici qu'il est également possible de créer le projet en ligne de commandes si vous disposer déjà d'Azure CLI ML avec la commande ci-après :

az ml project create -a <nom_du_compte_experimentation> -n <nom_du_projet> -g <nom_du_groupe_ressources> -w <nom_de_l_espace_de_travail> -r <URL_du_depot_GIT> --vststoken <cle_personnelle_vsts>

Remarque : Vous devez être en possession d'une clé personnelle VSTS pour utiliser cette commande. Vous pouvez lire la documentation officielle à ce sujet ici.

Remarque : Pour installer Azure CLI ML sur Windows, vous devez :

• Installer Python depuis https://www.python.org/. Assurez-vous de bien sélectionner l'installation de pip.
• Ouvrir une invite de commandes avec des privilèges d'administration à l'aide de Run As Administrator et exécuter les commandes suivantes :

   

pip install azure-cli

pip install azure-cli-ml

Remarque : Pour installer Azure CLI ML sur MacOS, vous devez ouvrir une invite de commandes et exécuter les commandes suivantes :

sudo -i

pip install azure-cli

pip install azure-cli-ml

Lier un projet existant à un dépôt GIT

Si vous avez créé un projet Azure ML sans dépôt Git, vous pouvez ultérieurement mettre à jour le projet pour ajouter le lien vers le dépôt Git avec la commande ci-dessous :

az ml project update –repo https://myteamazure.visualstudio.com/_git/myTeamProject

Remarque importante : Une fois qu'un projet est lié à Git, ce lien NE peut être supprimé !

Un projet Azure ML et GIT

Une fois que votre projet Azure ML est lié à un dépôt Git, une nouvelle branche est automatiquement sur votre dépôt distant appelé : AzureMLHistory/<Identifiant_du_projet>. Vous pouvez visualiser cette nouvelle branche sur « Team Services » :

A chaque fois que vous lancez une exécution de votre projet, toute modification est automatiquement sauvegardée et poussée dans cette branche :

Si vous souhaitez sauvegarder par vous-même vos modifications, vous pouvez faire un commit dans la branche master ou toute autre branche que vous avez créé. Cela vous permet, par exemple, de revenir dans un état antérieur tout en sauvegardant l'état dans lequel vous êtes actuellement.

Néanmoins, si vous téléchargez ce projet sur un autre poste de travail, la version sera celle du dernier commit de la branche AzureMLHistory/<identifiant_du_projet>.

Collaborer sur un projet Azure ML

Pour pouvoir collaborer sur un même projet Azure ML, les autres personnes doivent disposer des autorisations dans VSTS mais aussi au niveau du compte d'expérimentation de l'espace de travail concerné.

Vous pouvez ajouter des membres sur VSTS directement depuis l'interface web de VSTS (Cf. documentation officielle (en anglais) à ce sujet).

Pour ajouter un utilisateur sur un espace de travail ou un compte d'expérimentation, vous pouvez utiliser le portail Azure ou une invite de commandes.

Ajouter un utilisateur via le portail Azure

Naviguez vers le portail Azure. Une fois sur celui-ci, recherchez votre compte d'expérimentation sur lequel vous voulez donnez accès puis allez dans Contrôle d'accès (IAM) :

Sélectionnez Ajouter des autorisations, précisez le compte utilisateur ou un groupe d'utilisateurs déclaré dans le répertoire Azure AD auquel est associé l'abonnement Azure utilisé.

Sélectionner le rôle adéquate. Les rôles principalement utilisés sont Propriétaire (lecture, écriture et gestion des droits), Contributeur (lecteur et écriture) et Lecteur (lecture seule).

Ajouter un utilisateur via Azure ML CLI

Comme souligné précédemment, vous pouvez aussi passer par Azure ML CLI pour ajouter les droits à un utilisateur sur votre compte d'expérimentation ou votre espace de travail.

Pour utiliser Azure ML CLI depuis Azure ML Workbench, vous devez utiliser le menu File puis Open Command Prompt afin d'ouvrir une invite de commandes.

La première étape est de récupérer l'identifiant de la ressource concernée sur laquelle vous souhaitez que l'utilisateur aie accès :

• Pour un compte d'expérimentation, la commande est la suivante :

  az ml account experimentation show --query "id"

   

• Pour un espace de travail, la commande est comme suit :

  az ml workspace show --query "id"

Une fois l'identifiant récupérée, vous pouvez assigner le rôle de l'utilisateur avec la commande ci-dessous :

az role assignment create --assignee <identifiant_azure> --role [Contributor|Owner] --scope <identifiant_de_la_ressource>

Une fois la personne ajoutée aux deux ressources, cette dernière dispose d'un accès au projet et peut télécharger celui-ci sur son poste de travail.

Remarque : Il se peut que la personne avec qui vous collaborez doive redémarrer Azure ML Workbench pour prendre en compte les modifications d'accès.

Travailler en équipe sur un projet Azure ML

L'ensemble des personnes déclarées partagent la même branche master et le même historique d'exécutions. Ainsi, si l'une de ces personnes exécute le projet, les autres peuvent aussi accéder à l'état du projet à cet instant.

Il est donc parfois préférable de créer une autre branche pour ne pas avoir de souci de synchronisation entre les différentes versions d'un même projet puis d'effectuer des fusions de branche ultérieurement. Nous rentrons dans le classique de la vie d'un projet et de ses versions.

Ceci conclut ce billet sur la configuration d'un projet d'équipe et ainsi la capacité de collaborer à plusieurs sur un même objectif : nous sommes toujours plus intelligents à plusieurs que tout seul ;-)

Avec la nouvelle version de ce mois de décembre 2017 du service de gestion des modèles d'Azure ML, vous pouvez dorénavant déployer ce conteneur sur un appareil au plus près de la source des données typiquement pour les scénarios liés à l'Internet des objets (IoT). Au-delà d'un cloud « intelligent », cette approche permet de porter l'« intelligence en bordure ». C'est en particulier l'un des scénarios que permet d'aborder Azure IoT Edge, actuellement disponible en version préliminaire publique

Je vous propose d'aborder tout cela dans ce billet et j'en profite pour remercier Paul Jenny actuellement en stage de fin d'étude au sein de Microsoft France pour cette contribution.

Une rapide présentation d'Azure IoT Edge

Les appareils connectés qui composent ce qu'il convient d'appeler l'IoT sont typiquement situés en bordure du cloud. Ils n'ont généralement qu'une faible puissance de calcul ainsi des capacités de connexion réseau vers l'externe limitées (protocole(s) pris en charge, consommation induite, etc.).

Ainsi, les rendre « intelligents » avec l'Intelligence Artificielle (IA) devient vite compliquée à mettre en place dû à ces deux contraintes (calcul, réseau).

Afin de s'affranchir de ces contraintes, Azure IoT Edge permet d'apporter l'intelligence jusqu'en bordure du cloud afin d'offrir un ensemble de services cloud intelligent. Vous pourrez ainsi déployer vos propres applications ou des modèles (dans ou) au plus près de vos objets connectés en bordure et traiter en local les différentes données provenant de sources locales à l'objet considéré (capteurs de température, de pression, détecteur de présence, etc.. Un cas d'exemple serait l'utilisation d'Azure IoT Edge sur un moteur d'avion pour effectuer de la maintenance prédictive en cas de détection d'un risque élevé de panne proche.

La mise en place d'Azure IoT Edge

Pour pouvoir déployer sur Azure IoT Edge, il faut au préalable avoir configuré un hub Azure IoT ainsi qu'avoir configuré un module.

Remarque : Vous avez besoin d'un abonnement Azure pour pouvoir effectuer la suite de ce tutoriel. Si vous n'avez encore de compte Azure, vous pouvez créer un compte gratuit ici. Nous supposons que vous disposez à ce stade d'un tel compte.

La première étape est de configurer votre ordinateur ou votre machine virtuelle pour simuler un appareil IoT. Pour cela, vous devez installer Docker pour Windows et Python 2.7 . Ensuite, via une invite de commandes, vous devez installer le paquet de contrôle d'Azure IoT avec pip :

pip install -U azure-iot-edge-runtime-ctl

Vous devez ensuite créer un hub Azure IoT sur le portail Azure afin de pouvoir inscrire un appareil dans ce hub. Pour cela, vous pouvez passer par Azure Cloud Shell, le Shell intégré au portail d'Azure ou plutôt effectuer les mêmes opérations graphiquement.

La création de hub avec Azure Cloud Shell

Une fois connecté au Portail Azure, vous pouvez sélectionner dans la barre de tâches en haut du portail le Shell Azure en PowerShell ou Bash :

Il est recommandé de créer un groupe de ressources pour chaque projet afin de gérer au mieux vos ressources sur Azure. Dans le Shell situé ci-dessous, vous devez saisir la commande suivante :

az group create --name iotedge --location westeurope

Cette commande permet de créer un groupe de ressources nommé « iotedge » situé par exemple ici dans la région Azure en Europe de l'Ouest.

Remarque : Le nom d'un groupe de ressources doit être unique à travers Azure. Il se peut ainsi que ce nom puisse déjà être utilisé par quelqu'un d'autre.

La seconde étape est de créer l'hub Azure IoT dans ce groupe de ressources :

az iot hub create --resource-group iotedge --name moniothub --sku F1

Cette commande permet de créer un hub IoT dans le groupe de ressources iotedge avec pour nom moniothub et le plan de tarification F1 pour les besoins de ce tutoriel (gratuit, limité à un par abonnement Azure).

Créer le hub depuis le portail Azure

Une fois connecté au portail Azure, vous pouvez sélectionner sur la droite Créer une ressource :

Recherchez ensuite IoT Hub :

Puis sélectionnez la ressource IoT Hub et enfin Créer.

Dans le formulaire, vous devez indiquer le nom de votre hub IoT (il doit être unique). Choisissez ensuite le niveau de tarification F1, correspondant au niveau gratuit, suffisant pour effectuer nos tests (limité à un par abonnement Azure).

Concernant le groupe de ressources, il est recommandé de créer un groupe de ressources pour chaque projet sur Azure afin de pouvoir organiser les ressources au mieux. Vous pouvez néanmoins en utiliser un existant si vous le souhaitez. Une fois tout ceci fait, il suffit de cliquer sur Créer.

Il faut maintenant attendre le déploiement de cette nouvelle ressource dans Azure.

L'inscription d'un appareil IoT Edge

Une fois votre hub IoT déployé, vous pouvez maintenant ajouter un appareil IoT Edge dans celui-ci. Sur le portail Azure, sélectionnez votre hub sur le tableau de bord sinon recherchez-le via le menu Toutes les ressources à gauche :

Une fois le panneau du hub ouvert, sélectionnez IoT Edge (preview) dans le menu à gauche :

Il faut maintenant ajouter un appareil IoT à votre hub avec le bouton Add IoT Edge Device :

Dans l'approche suggérée ici pour les besoins de notre illustration, cet appareil est votre ordinateur ou votre machine virtuelle. Dans le formulaire qui vient de s'ouvrir sur la droite, vous devrez insérer l'ID de l'appareil. Celui-ci doit être unique et doit être composé de caractères alphanumériques. Ensuite, il est préférable de laisser Azure générer automatiquement les clés SSH associées à votre appareil pour la connexion.

Une fois l'appareil ajouté, il faut le configurer pour accéder à votre hub IoT. Pour cela, il convient au préalable récupérer les clés de connexion. Pour ce faire, sélectionnez-le dans la liste des appareils de votre hub IoT :

Dans la nouvelle fenêtre, copiez la Chaîne de connexion - clé primaire et conservez-la dans votre presse-papiers.

Vous pouvez maintenant passer à la configuration de votre appareil IoT. Ouvrez maintenant un terminal de commandes sur votre ordinateur ou machine virtuelle puis saisissez la commande suivante :

iotedgectl setup --connection-string [VOTRE_CHAINE_CONNEXION] --auto-cert-gen-force-no-passwords

Cette commande permet de configure votre appareil IoT avec votre hub IoT Azure. Deux modules (sous forme de conteneur Docker) sont ainsi déployés, à savoir :

1. L'agent IoT Edge qui gère le déploiement et la surveillance des modules de votre appareil IoT
2. L'agent hub IoT qui gère la communication entre vos modules et votre hub IoT.

La dernière étape consiste enfin à lancer vos modules IoT avec la commande suivante :

iotedgectl start

Vous pouvez vérifier que tout fonctionne bien avec la commande Docker qui permet de lister les conteneurs actifs :

docker ps

Vous devez avoir le conteneur basé sur l'image « microsoft/azureiotedge-agent:1.0-preview » qui fonctionne.

La création de votre image Docker

Pour pouvoir déployer votre modèle sur votre module IoT, la première étape est de créer l'image Docker associée à celui-ci.

Si vous n'avez pas lu l'article sur le déploiement d'un modèle sous forme de service web ici, nous vous invitons à le consulter au préalable. Les différentes étapes et explications sont décrites dans ce billet.

Pour les besoins de ce billet, vous pouvez utiliser l'exemple fourni par le tutoriel officiel en téléchargeant le fichier score ici et le modèle ici. Ensuite, il vous suffit avec une invite de commandes de saisir la commande ci-dessous dans le dossier contenant les deux fichiers précédents :

az ml service create realtime –model-file model.pkl -f iot_score.py -n machinelearningmodule -r python

Cette commande permet de créer le manifeste, de générer l'image Docker associée et enfin de publier le service web. Celui-ci est appelé machinelearningmodule tout comme l'image Docker.

Le déploiement de votre modèle en module IoT

Pour pouvoir récupérer l'image Docker de votre modèle, il faut ajouter la connexion au répertoire Docker à votre appareil IoT. Pour cela, il faut au préalable récupérer les identifiants de connexion de votre Azure Container Registry qui a été créé lors de la création de votre environnement de déploiement :

Pour ce faire, rendez-vous sur le portail Azure et accédez au menu Toutes les ressources situé à droite :

Si vous possédez plusieurs environnements de déploiements, vous pouvez utiliser la commande suivante depuis un invite de commandes pour rechercher rapidement le groupe de ressources associé à votre registre de conteneurs où l'image Docker a été déployé, :

az ml env show -n [VOTRE_ENVIRONNEMENT] -v

Recherchez dans le résultat de la commande la propriété containerRegistry , puis resourceId. L'URL est sous la forme :

[VOTRE_ID_ABONNEMENT] / resourcegroups / [VOTRE_ID_GROUPE_RESSOURCES] / providers / ….

La partie importante ici est [VOTRE_ID_GROUPE_RESSOURCES]. Par exemple, ci-dessous, le groupe de ressources serait PaulML-azureml-7f27d :

Une fois que vous disposez du groupe de ressources dans lequel se trouve votre registre de conteneurs, il vous suffit de le sélectionner sur le portail Azure :

Dans la nouvelle fenêtre, accédez au menu Clés d'accès :

Vous aurez ainsi besoin du serveur de connexion et du nom d'utilisateur et mot de passe associés :

Vous allez enfin pouvoir ajouter la connexion à ce répertoire Docker à votre appareil IoT. Pour cela, dans une invite de commandes, saisissez la commande suivante en remplaçant les valeurs avec les données que vous avez récupérées ci-dessus :

iotedgectl login –address [SERVEUR_CONNEXION] –username [NOM_UTILISATEUR] –password [MOT_DE_PASSE]

Une fois ceci fait, vous pouvez passer au déploiement en tant que tel du module contenant votre image Docker sur votre appareil IoT. Pour cela, toujours sur le portail Azure, allez sur votre hub IoT puis dans le menu IoT Edge (preview) puis sélectionnez votre appareil IoT. Cliquez ensuite sur Set Modules située en haut du menu :

Nous allons à présent ajouter le module à cet appareil IoT en cliquant sur Add IoT Edge Module :

Dans le menu déroulant à droite, vous devez donner un nom à ce module IoT puis indiquer l'image Docker sur lequel le conteneur sera basé. L'URI vers l'image est sous la forme :

[SERVEUR_CONNEXION_DOCKER] / [NOM_IMAGE] :1

Par exemple, ici, avec le nom d'image que nous avons utilisé auparavant, ce serait :

mlcrparc4ff11505f691.azurecr.io/machinelearningmodule :1

Une fois le formulaire rempli, cliquez sur Next.

La seconde étape permet de créer des routes personnalisées inter-modules ou avec l'hub IoT. Ici, le service web devrait fonctionner de lui-même sans personnalisation supplémentaire.

Puis cliquez sur Next et enfin Submit. Une demande de déploiement sur votre appareil IoT est ainsi créé. Une fois celui-ci achevé, vous aurez une notification dans le portail Azure :

Ensuite, pour pouvoir envoyer des messages à votre module IoT afin de prédire des données, deux options s'offrent à vous : i ) utiliser le portail Azure ou ii) développer votre propre solution.

L'envoi des messages vers votre module IoT

Via un code personnalisé

La documentation officielle recense différents exemples pour pouvoir contacter votre module IoT dans plusieurs langages.

• Un exemple en .NET ;
• Un exemple en Java ;
• Un exemple en NodeJS.

Via le portail Azure

Vous pouvez envoyer des messages depuis le portail Azure avec votre hub IoT. Pour cela, retournez dans la configuration de votre hub IoT. Sélectionnez ensuite le module vers lequel vous souhaitez envoyer un message puis cliquez sur Message à l'appareil :

Entrez dans le Corps du message les données que vous souhaitez prédire selon le format attendu par votre service web :

En guise de conclusion

Nous espérons que ce billet vous aura permis de découvrir comment déployer un modèle d'Azure ML vers un module IoT empaqueté dans un conteneur Docker sous forme de service web. Ceci clôt notre billet.

Enfin, si besoin, vous pouvez retrouver la documentation officielle d'Azure IoT Edge ici ainsi que le tutoriel de démarrage ici associé.