Comment utiliser le modèle d'IA médicale MedImageParse pour la segmentation des images médicales
Important
Les éléments marqués (préversion) dans cet article sont actuellement en préversion publique. Cette préversion est fournie sans contrat de niveau de service, nous la déconseillons dans des charges de travail de production. Certaines fonctionnalités peuvent être limitées ou non prises en charge. Pour plus d’informations, consultez Conditions d’Utilisation Supplémentaires relatives aux Évaluations Microsoft Azure.
Important
Les modèles IA de santé sont destinés à la recherche et à l’exploration du développement de modèles. Les modèles ne sont pas conçus ou destinés à être déployés dans un cadre clinique, car ils ne sont pas utilisés dans le diagnostic ou le traitement de conditions de santé ou médicales, et les performances des modèles individuels à ces fins n’ont pas été établies. Vous êtes seul responsable de toute utilisation des modèles IA de santé, y compris la vérification des sorties et l’incorporation dans n’importe quel produit ou service destiné à un but médical ou pour informer la prise de décision clinique, de la conformité aux lois et réglementations applicables aux soins de santé, ainsi que l’obtention des autorisations ou approbations nécessaires.
Dans cet article, vous apprendrez à déployer MedImageParse en tant que point de terminaison en ligne pour l'inférence en temps réel et à émettre un appel de base à l'API. Voici les étapes à suivre :
- Déployer le modèle sur un calcul managé auto-hébergé.
- Accorder des autorisations au point de terminaison.
- Envoyez des données de test au modèle, recevez et interprétez les résultats.
MedImageParse - segmentation d'images médicales basée sur des invites
L’analyse d’images biomédicales est essentielle à la découverte dans des domaines tels que la biologie cellulaire, la pathologie et la radiologie. Traditionnellement, les tâches telles que la segmentation, la détection et la reconnaissance des objets pertinents sont traitées séparément, ce qui peut limiter l’efficacité globale de l’analyse d’images. Cependant, MedImageParse unifie ces tâches grâce à l'analyse d'images, en effectuant conjointement la segmentation, la détection et la reconnaissance sur de nombreux types d'objets et modalités d'imagerie. En appliquant les interdépendances entre ces sous-tâches, telles que les étiquettes sémantiques des objets segmentés, le modèle améliore la précision et permet de nouvelles applications. Par exemple, il permet aux utilisateurs de segmenter tous les objets pertinents dans une image, en utilisant une simple invite de texte. Cette approche élimine le besoin de spécifier manuellement les cadres de délimitation pour chaque objet.
L'image suivante montre l'architecture conceptuelle du modèle MedImageParse où un modèle d'intégration d'images est augmenté d'une couche d'adaptation de tâches pour produire des masques de segmentation et des descriptions textuelles.
Il est remarquable que les masques de segmentation et les descriptions textuelles aient été obtenus en utilisant uniquement des ensembles de données de segmentation standard, complétés par des étiquettes en langage naturel ou des descriptions harmonisées avec des ontologies d’objets biomédicaux établies. Cette approche a non seulement amélioré les performances des tâches individuelles, mais a également offert un outil tout-en-un pour l’analyse d’images biomédicales, ouvrant la voie à une découverte biomédicale basée sur l’image plus efficace et plus précise.
Prérequis
Pour utiliser le modèle MedImageParse, les prérequis sont les suivants :
Un modèle de déploiement
Déploiement sur un calcul managé auto-hébergé
Le modèle MedImageParse peut être déployé sur notre solution d'inférence gérée auto-hébergée, qui vous permet de personnaliser et de contrôler tous les détails sur la manière dont le modèle est servi. Vous pouvez déployer le modèle via l’interface utilisateur du catalogue (dans AI Studio ou Azure Machine Learning studio) ou déployer par programmation.
Pour déployer le modèle via l’interface utilisateur :
Accédez au catalogue.
Recherchez MedImageParse et sélectionnez la carte de modèle.
Dans la page de vue d’ensemble du modèle, sélectionnez Déployer.
Si vous avez la possibilité de choisir entre un déploiement d’API serverless et un déploiement avec un calcul managé, sélectionnez Calcul managé.
Renseignez les détails dans la fenêtre du déploiement.
Remarque
Pour un déploiement sur un calcul managé auto-hébergé, vous devez disposer d’un quota suffisant dans votre abonnement. Si vous n’avez pas suffisamment de quota disponible, vous pouvez utiliser notre accès temporaire au quota en sélectionnant l’option Je souhaite utiliser le quota partagé et je reconnais que ce point de terminaison sera supprimé dans 168 heures.
Sélectionnez Déployer.
Pour déployer le modèle par programmation, consultez Comment déployer et inférer un déploiement de calcul géré avec du code.
Travaillez avec un modèle de segmentation
Dans cette section, vous consommez le modèle et lui effectuez des appels de base.
Utilisez l'API REST pour consommer le modèle
Utilisez le modèle de segmentation MedImageParse en tant qu'API REST, en utilisant de simples requêtes GET ou en créant un client comme suit :
from azure.ai.ml import MLClient
from azure.identity import DeviceCodeCredential
credential = DefaultAzureCredential()
ml_client_workspace = MLClient.from_config(credential)
Dans la configuration de déploiement, vous pouvez choisir la méthode d’authentification. Cet exemple utilise l’authentification basée sur des jetons Azure Machine Learning. Pour plus d’options d’authentification, consultez la page de documentation correspondante. Notez également que le client est créé à partir d’un fichier de configuration créé automatiquement pour les machines virtuelles Azure Machine Learning. Pour en savoir plus, consultez la page de documentation de l’API correspondante.
Effectuez des appels de base au modèle
Une fois le modèle déployé, utilisez le code suivant pour envoyer des données et récupérer des masques de segmentation.
import base64
import json
import os
sample_image_xray = os.path.join(image_path)
def read_image(image_path):
with open(image_path, "rb") as f:
return f.read()
sample_image = "sample_image.png"
data = {
"input_data": {
"columns": [ "image", "text" ],
"index": [ 0 ],
"data": [
[
base64.encodebytes(read_image(sample_image)).decode("utf-8"),
"neoplastic cells in breast pathology & inflammatory cells"
]
]
}
}
data_json = json.dumps(data)
# Create request json
request_file_name = "sample_request_data.json"
with open(request_file_name, "w") as request_file:
json.dump(data, request_file)
response = ml_client_workspace.online_endpoints.invoke(
endpoint_name=endpoint_name,
deployment_name=deployment_name,
request_file=request_file_name,
)
Utilisez l'API REST MedImageParse
Le modèle MedImageParse suppose une interaction simple à un seul tour où une requête produit une réponse.
Schéma de requête
La charge utile de la requête est une chaîne au format JSON contenant les paramètres suivants :
| Clé | Type | Obligatoire/Par défaut | Description |
|---|---|---|---|
input_data |
[object] |
Y | Un objet contenant la charge utile des données d'entrée |
L'objet input_data contient les champs suivants :
| Clé | Type | Obligatoire/Par défaut | Valeurs autorisées | Description |
|---|---|---|---|---|
columns |
list[string] |
Y | "image", "text" |
Un objet contenant les chaînes mappant les données aux entrées passées au modèle. |
index |
integer |
Y | 0 - 256 | Nombre d'entrées transmises au modèle. Vous êtes limité par la quantité de données pouvant être transmises dans une seule requête POST, ce qui dépend de la taille de vos images. Il est donc raisonnable de maintenir ce nombre à quelques dizaines. |
data |
list[list[string]] |
Y | "" | La liste contient les éléments passés au modèle qui est défini par le paramètre index. Chaque élément est une liste de deux chaînes. L'ordre est défini par le paramètre columns. La chaîne text contient le texte de l'invite. La chaîne image correspond aux octets de l'image codés en base64 et décodés sous forme de chaîne utf-8. NOTE : l'image doit être redimensionnée en pixels 1024x1024 avant d'être soumise au modèle, en préservant le rapport hauteur/largeur. L'espace vide doit être rempli de pixels noirs. Consultez l'exemple de bloc-notes Génération de segmentation pour une variété de modalités d'imagerie pour un exemple de code de redimensionnement et de remplissage.Le texte d'entrée est une chaîne contenant plusieurs phrases séparées par le caractère spécial &. Par exemple : tumor core & enhancing tumor & non-enhancing tumor. Dans ce cas, il y a trois phrases, donc la sortie se compose de trois images avec des masques de segmentation. |
Exemple de requête
Requête de segmentation de toutes les cellules d'une image de pathologie
{
"input_data": {
"columns": [
"image",
"text"
],
"index":[0],
"data": [
["iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAYAAABytg0kAAAAAXNSR0IArs4c6QAAAARnQU1BAACx\njwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAAbSURBVBhXY/gUoPS/fhfDfwaGJe///9/J8B8A\nVGwJ5VDvPeYAAAAASUVORK5CYII=\n",
"neoplastic & inflammatory cells "]
]
}
}
Schéma de réponse
La charge utile de réponse est une liste de chaînes au format JSON, chacune correspondant à une image soumise. Chaque chaîne contient un objet segmentation_object.
segmentation_object contient les champs suivants :
| Clé | Type | Description |
|---|---|---|
image_features |
segmentation_mask |
Un objet représentant les masques de segmentation pour une image donnée |
text_features |
list[string] |
Liste de chaînes, une pour chaque chaîne de texte soumise, classant les masques de segmentation dans l'une des 16 catégories de segmentation biomédicale chacune : liver, lung, kidney, pancreas, heart anatomies, brain anatomies, eye anatomies, vessel, other organ, tumor, infection, other lesion, fluid disturbance, other abnormality, histology structure, other |
segmentation_mask contient les champs suivants :
| Clé | Type | Description |
|---|---|---|
data |
string |
Un base64-encoded NumPy contenant le masque de segmentation codé à chaud. Il peut y avoir plusieurs instances d’objets dans le tableau renvoyé. Décodez et utilisez np.frombuffer pour désérialiser. Le tableau contient une matrice tridimensionnelle. La taille du tableau est 1024x1024 (correspondant aux dimensions de l'image d'entrée), la troisième dimension représentant le nombre de phrases d'entrée fournies. Consultez les exemples de cahiers fournis pour des exemples de décodage et d'utilisation. |
shape |
list[int] |
Une liste représentant la forme du tableau (généralement [NUM_PROMPTS, 1024, 1024]) |
dtype |
string |
Une instance de la classe NumPy dtype sérialisée en une chaîne. Décrit le conditionnement des données dans le tableau de données. |
Exemple de réponse
Une inférence simple demandant la segmentation de deux objets
[
{
"image_features": "{
'data': '4oCwUE5HDQoa...',
'shape': [2, 1024, 1024],
'dtype': 'uint8'}",
"text_features": ['liver', 'pancreas']
}
]
Formats d’image pris en charge
L'API du modèle déployé prend en charge les images codées au format PNG. Pour des résultats optimaux, nous vous recommandons d'utiliser des PNG non compressés/sans perte avec des images RGB.
Comme décrit dans la spécification de l'API, le modèle accepte uniquement les images dans une résolution de 1024x1024pixels. Les images doivent être redimensionnées et complétées (dans le cas d'un rapport hauteur/largeur non carré).
Consultez le bloc-notes Génération de segmentation pour une variété de modalités d'imagerie pour connaître les techniques et les exemples de code utiles à la soumission d'images de différentes tailles stockées à l'aide de divers formats d'imagerie biomédicale.
En savoir plus à partir d'échantillons
MedImageParse est un modèle polyvalent qui peut être appliqué à un large éventail de tâches et de modalités d'imagerie. Pour plus d'exemples, consultez les notebooks Python interactifs suivants :
Mise en route
- Déploiement et utilisation de MedImageParse : découvrez comment déployer le modèle MedImageParse et l'intégrer à votre flux de travail.
Techniques d'inférence avancées et exemples
- Génération de segmentation pour une variété de modalités d'imagerie : comprenez comment utiliser MedImageParse pour segmenter une grande variété d'images médicales différentes et apprenez quelques techniques d'invite.