Nous avons organisé un webinaire pour présenter la nouvelle version de notre plateforme, désormais centrée sur MLOps, et plus précisément, sur CVOps-MLOpsapplied computer vision. Chez Picsellia, nous offrons une plateforme de vision par ordinateur (CV) de bout en bout qui vous permet de gérer les données d'IA, d'exécuter des expériences, de déployer des modèles en production et de les surveiller avec des pipelines automatisés.
Pour vous présenter les nouvelles fonctionnalités de Picsellia, nous avons préparé un cas d'utilisation en collaboration avec le Centre de recherche sur le cancer de Toulouse. Si vous souhaitez regarder un replay de notre webinar, il est disponible sur youtube, juste ici!
Résumé
- À propos du cas d'utilisation
- Annotation de votre ensemble de données
- Formation de votre modèle
- Lancement de l'expérience
- Exportation du modèle
- Déploiement du modèle
- Faire des prédictions/inférences
- Entraînement d'un modèle sur un jeu de données personnalisé de noyaux de fibroblastes
- Formation continue et système d'alerte
- Comparaison des modèles d'ombre
À propos du cas d'utilisation
Ce cas d'utilisation a été possible grâce au Centre de recherche sur le cancer de Toulouse, dont les collaborateurs ont partagé avec nous certains des obstacles qu'ils rencontrent dans leurs essais et leurs recherches.
Le centre étudie la propagation des cellules cancéreuses au microscope et cherche à savoir comment certaines autres cellules présentes à l'état naturel dans notre corps, appelées fibroblastes, contribuent à la propagation du cancer.
Aujourd'hui, ce que les scientifiques mesurent en matière de propagation, c'est la fluorescence globale. En activant certaines enzymes sur les cellules, ils peuvent contrôler la fluorescence globale d'une image. Mais, cette fluorescence doit être rapportée au nombre de cellules de la photo pour avoir des résultats significatifs.
Le simple comptage des cellules d'une image peut prendre de 2 à 3 heures, jusqu'à 10 à 12 heures par semaine, ce qui entrave leur processus de recherche.
Chez Picsellia, nous avons pensé que l'IA et la vision par ordinateur pourraient les aider à détecter le noyau de ces cellules et à automatiser le processus de comptage des cellules, ramenant le processus de comptage de 10 heures à quelque chose comme 2 à 3 minutes pour un millier d'images.
Méthodologie
En bref, nous allons essayer d'entraîner un nouveau modèle qui servira de modèle de base sur notre jeu de données, puis nous l'affinerons et l'utiliserons pour pré-annoter nos images et voir comment il se comporte. Notre jeu de données était adapté à la segmentation, mais nous l'utiliserons pour la détection d'objets, juste pour simplifier le cas d'utilisation, et parce que la détection d'objets est adaptée au comptage de cellules.
Annotation de votre ensemble de données
Nous allons commencer par le lac de données. C'est là que tous les actifs stockés peuvent être visualisés et recherchés, par exemple par balise ou autres attributs.
Ici, nous avons beaucoup plus d'images que nécessaire pour notre cas d'utilisation, nous allons donc filtrer uniquement les images de l'ensemble de données Nature, par le tag "nature".
Nous voyons que nous ne listons que 79 images, ce qui correspond à la taille de l'ensemble de données original. Nous pouvons également passer à une vue en liste et voir le nom de fichier et les attributs des images.
Maintenant nous devons les sélectionner toutes et créer un jeu de données Picsellia que nous appellerons "empty_images".
Comme il devrait être créé maintenant, nous pouvons nous diriger vers le jeu de données. Sélectionnons le jeu de données que nous voulons et la version "empty_images" que nous venons de créer.
Dans un jeu de données, vous pouvez importer des annotations. Comme le jeu de données sur la nature était déjà étiqueté, nous avons importé les annotations dans une nouvelle version de notre jeu de données.
Nous retournons à nos ensembles de données, et choisissons celui qui est déjà annoté.
Une fois là, nous pouvons visualiser toutes les annotations qui ont été faites. La cohérence semble assez bonne et toutes les cellules sont étiquetées.
Si nous sélectionnons une image et passons à notre outil d'annotation, nous pouvons, si nécessaire, modifier les annotations une par une, ou créer une nouvelle annotation avec notre interface d'annotation collaborative.
Comme indiqué ci-dessous, dans le lac de données, vous pouvez filtrer vos images par attribut, y compris les objets dans les annotations. Par exemple, nous pouvons choisir de visualiser toutes les images qui contiennent plus de 20 cellules annotées, et voir que cela réduit le nombre d'images à 56.
Formation de votre modèle
Maintenant que nous sommes satisfaits de notre ensemble de données entièrement annotées, nous pouvons passer à l'entraînement du modèle.
Créons un nouveau projet. Nous allons l'appeler base-nature-cells, inviter notre équipe et le valider.
Ensuite, nous allons attacher le jeu de données que nous venons de créer (avec les annotations) à notre projet, et ce sera la source de l'expérience que nous allons créer maintenant.
Appelons-le v0 et choisissons dans notre modèle HUB un modèle efficaceDet-d2 adapté à la détection d'objets.
Nous allons conserver les paramètres de base pour l'instant, sélectionner notre jeu de données et créer notre expérience.
Voici le tableau de bord de notre expérience. Il est vide pour le moment mais nous pouvons déjà vérifier qu'il a attaché toutes les ressources dont nous avons besoin, comme le modèle de base, l'ensemble de données et les paramètres.
Lancement de l'expérience
Maintenant, nous voulons lancer notre expérience à distance en allant simplement sur l'onglet "launch" de , et en cliquant sur le bouton "launch". Picsellia propose déjà un code packagé pour les modèles de notre hub, ce qui nous permet de lancer la formation de manière transparente.
Nous pouvons maintenant passer à l'onglet "télémétrie" où nous pouvons voir les journaux du serveur GPU en temps réel et nous assurer que notre modèle s'entraîne correctement.
Si nous revenons à l'onglet "logs", nous pouvons voir que nous avons déjà certaines mesures telles que le train-split et la perte qui est enregistrée en temps réel pendant l'entraînement mais a l'historique de l'activité, qui est le train/test split de l'ensemble de données et quelques époques déjà pour lesquelles nous pouvons vérifier la perte en temps réel.
Quelques heures plus tard, nous voulons vérifier l'onglet "télémétrie". Il a fallu trois heures pour que les expériences se terminent.
Maintenant, nous pouvons voir que notre formation est terminée et que tout a été enregistré correctement. Nous pouvons même faire une vérification approfondie. Dans ce cas, nous pouvons observer que l'évaluation et le téléchargement des artefacts se sont bien passés.
Revenons à notre tableau de bord pour voir toutes nos mesures de formation. Nous avons maintenant beaucoup plus d'informations. Nous avons tous les graphiques des différentes courbes de perte, nos métriques d'évaluation, et plus encore. Nous pouvons observer que notre perte semble avoir atteint un minimum, et dire que c'est assez bon pour les effets de cette démo.
Exportation du modèle
Ensuite, nous voulons exporter l'expérience (cliquez sur le bouton "exporter" en haut à droite). En d'autres termes, nous allons convertir l'expérience en un modèle et le sauvegarder dans notre registre, que nous pourrons déployer.
Cela nous conduit à notre registre dans la page "modèle", où nous pouvons accéder aux fichiers dont il dispose pour se recycler ou se déployer, à la carte des étiquettes, aux données d'entraînement et à l'expérience originale.
Déploiement du modèle
Ensuite, cliquez sur "déployer" et définissez un seuil de confiance minimum pour limiter le bruit dans nos prédictions.
Et nous venons de créer un modèle déployé !
Faire des prédictions/inférences
Maintenant, nous voulons faire des prédictions avec notre modèle, pour cela il suffit de copier le nom du déploiement et de se rendre dans un ordinateur portable ou n'importe où vous pouvez faire un appel API.
Nous allons utiliser notre SDK Python pour appeler notre déploiement. Avec une méthode simple, nous allons nous authentifier et récupérer les informations du déploiement. Ensuite, nous devrons sélectionner un dossier contenant des images sur lesquelles nous voulons effectuer des prédictions, et les envoyer au modèle avec la méthode predict.
Ce qui est génial avec Picsellia, c'est que nous pouvons voir les prédictions en direct dans le tableau de bord. Nous disposons d'informations simples mais essentielles, comme la latence du modèle.
Envoyons-en quelques autres pour tracer un meilleur graphique. Nous pouvons voir que notre modèle a une latence moyenne de 210 ms, ce qui est plutôt bon pour une première étape.
Si nous allons dans l'onglet "prédictions", nous pouvons maintenant voir toutes les prédictions faites par notre modèle, (cela devrait vous rappeler l'onglet Dataset).
Comme nous pouvons le voir, notre modèle détecte nos cellules mais il y a encore beaucoup de bruit dans les prédictions, nous devrons donc nettoyer cela pour recycler un autre modèle.
Avant de procéder à la révision, nous allons mettre en place ce que nous appelons la "boucle de rétroaction" dans nos paramètres de déploiement, qui définit un ensemble de données cible où nos prédictions révisées vont atterrir.
Nous pouvons maintenant revoir nos prédictions. Il s'agit essentiellement du même processus que l'étiquetage de vos données la première fois, sauf que vous pouvez filtrer les prédictions par seuil de confiance, puis modifier les objets pour rendre les annotations aussi nettes et rapides que possible.
Si nous retournons à notre tableau de bord, nous aurons maintenant accès à des métriques plus intéressantes pour assurer la qualité des prédictions du modèle. Vous trouverez des métriques de détection d'objets purs telles que le rappel moyen, la précision moyenne, la distribution globale et par prédiction des étiquettes, des informations sur la distribution des images et également la détection automatique de la dérive des données.
Maintenant, nous avons un modèle de base qui fait des prédictions plutôt correctes, mais notre objectif final est de former un modèle qui sera performant sur notre ensemble de données personnalisé.
Entraînement d'un modèle sur un jeu de données personnalisé de noyaux de fibroblastes
Le processus consistera à envoyer toutes les images à notre modèle, qui effectuera des pré-annotations, puis les affinera afin de créer un ensemble de données propre pour réentraîner un nouveau modèle adapté à notre cas d'utilisation.
Prévisons nos images. On peut voir qu'il a détecté certains de nos noyaux. Allons vérifier ces prédictions de plus près.
Une fois encore, nous révisons et modifions les nouvelles prédictions du mieux que nous pouvons - ce qui est souvent assez facile grâce au curseur de seuil.
Comme vous vous en souvenez peut-être, nous avons configuré plus tôt, dans les paramètres de notre déploiement, ce que nous appelons une boucle de rétroaction. Cela signifie que maintenant que nous avons envoyé toutes nos photos au modèle et que nous les avons examinées, elles apparaîtront toutes ici et serviront de données de formation.
Nous pouvons constater que le jeu de données est composé de 30 images et comporte 712 objets annotés, ce qui n'est pas suffisant pour entraîner un modèle de détection d'objets.
Pour l'améliorer, nous allons procéder à une augmentation des données à l'aide d'un script que nous avons préparé en parallèle, en utilisant une manipulation classique des images, ce qui nous conduit à cette version de l'ensemble de données. Les images ont été recadrées, zoomées et tournées de manière aléatoire afin de créer facilement de nouveaux échantillons. Les dimensions semblent meilleures maintenant que nous avons près de 700 images et 18000 objets.
Maintenant que nous avons notre jeu de données, nous allons suivre le même processus que notre première formation. Nous allons créer un projet et joindre notre jeu de données augmenté.
Et encore une fois, créez une expérience qui s'occupera de la partie formation. Pour cela, nous allons choisir le même modèle de base que précédemment et créer notre expérience. Pour être clair, nous ne voulons pas utiliser notre modèle pré-entraîné des cellules de base pour entraîner celui-ci. Le but ici était d'utiliser le premier modèle entraîné pour pré-annoter les données afin de nous aider à passer plus rapidement à la deuxième itération. Ce n'est pas ce que nous avons fait ici, et c'est la raison pour laquelle nous utilisons toujours une architecture det_d2 efficace pour la formation. Mais, une autre stratégie aurait été d'utiliser ce modèle comme architecture de base pour notre expérience.
Encore une fois, nous allons le lancer à distance.
Vérifions que notre formation se déroule correctement !
Nous retournons au tableau de bord de notre projet quelques heures plus tard, et nous pouvons voir des expériences réussies. Nous en avons deux car nous n'étions pas satisfaits des performances de la première.
Jetons un coup d'œil aux journaux du serveur pour vérifier que tout va bien.
Là encore, nous allons également convertir cette expérience en modèle dans notre registre.
Créons un nouveau déploiement !
Nous allons définir le même seuil de confiance que précédemment.
Formation continue et système d'alerte
Puis nous nous dirigerons vers notre nouveau déploiement. Avant de lancer quelques prédictions, nous allons d'abord configurer nos déploiements avec quelques nouvelles fonctionnalités différentes du précédent : l'entraînement continu et le système d'alerte.
Pour donner un peu de contexte, la formation continue est la capacité de regarder un déclencheur qui lancera une expérience simple ; dans notre cas avec quelques paramètres prédéfinis, un modèle de base et un ensemble de données. Comme nous avons tous nos actifs centralisés dans Picsellia, il est très facile de le faire.
Dans notre cas, pour les besoins du webinaire, nous voulons que la boucle de formation continue se lance après l'examen de 3 nouveaux échantillons des prédictions. Nous avons également une alerte par défaut sur la latence du modèle qui nous enverra des notifications si la latence dépasse 100ms.
Nous allons maintenant configurer des alertes par défaut qui seront déclenchées sur la latence du modèle. Si le modèle dépasse 100 ms, nous devrions voir des alertes sur le tableau de bord.
Nous allons maintenant faire des prédictions avec quelques images originales que nous avons gardées de côté et voir comment notre modèle se comporte. Nous pouvons déjà voir que notre modèle a déclenché nos alertes - sa latence est 2 à 3 fois supérieure au seuil de 100 ms que nous avons fixé précédemment.
Ensuite, nous allons passer en revue 3 images, afin de lancer notre boucle d'entraînement continu.
Une fois que nous avons fait cela, une formation sera automatiquement lancée dans le projet utilisé pour former le premier modèle.
Et, quelques minutes plus tard, nous pouvons voir que l'état de notre expérience est un succès !
Cela signifie que si nous revenons à notre déploiement, nous devrions voir quelque chose de nouveau.
Comparaison des modèles d'ombre
L'onglet en haut de l'écran nous indique que nous avons un nouveau modèle prêt à partir de la boucle de formation continue, qui peut être déployé.
Nous le déploierons en tant que modèle fantôme pour voir comment il se comporte par rapport à notre premier et actuel modèle de production. En bref, le modèle fantôme ne sera là que pour comprendre s'il est plus performant que l'autre.
Le modèle a été déployé avec succès. Maintenant, nous allons refaire quelques prédictions, et nous pouvons voir que nous pouvons directement comparer notre modèle de production avec le modèle fantôme sans aucun effort.
Il semblait que le modèle fantôme avait quelques problèmes de latence au début, mais il a maintenant la même latence que notre premier modèle. Et, si nous regardons de plus près, nous pouvons voir que la latence moyenne du modèle fantôme est même meilleure que celle du modèle original, qui était de quelques dizaines de millisecondes.
Si nous le souhaitons, nous pouvons étudier une prédiction particulière en cliquant simplement sur un point quelconque du graphique. Cela nous aide à identifier et à mieux comprendre les valeurs aberrantes provenant de la prédiction.
Nous pouvons constater que notre modèle d'ombre semble être un peu plus performant que le précédent, à en juger par sa latence.
Nous pouvons retourner à notre onglet de prédiction une dernière fois et commencer à examiner certaines images pour garantir la qualité des prédictions du modèle d'ombre - la même vérité de base sera comparée entre la prédiction du modèle original et celle du modèle d'ombre.
Nous pouvons voir que nous avons à nouveau de nouvelles métriques dans notre tableau de bord, avec des informations sur le modèle fantôme. Cela nous aidera à prendre la meilleure décision quant au moment de déployer le nouveau modèle en production.
Ici, si nous basons notre décision uniquement sur la latence, nous choisissons de promouvoir le modèle fantôme en tant que champion, et donc, notre ancien modèle n'est plus le modèle de production et a été remplacé par notre modèle fantôme.
Enfin, la boucle est bouclée entre les données de formation, le déploiement et le suivi de la vision par ordinateur, ce que nous appelons CVOps.
Si vous souhaitez essayer Picsellia gratuitement, vous pouvez directement réserver un appel rapide ici pour que nous puissions vous organiser !
