Comment utiliser des modèles d’IA de santé MedImageParse pour la segmentation des images médicales

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 des modèles de segmentation d’images basés sur les invites, MedImageParse et MedImageParse 3D, en tant que points de terminaison en ligne pour l’inférence en temps réel. Vous voyez également comment émettre des appels 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

MedImageParse

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.

MedImageParse 3D

MedImageParse 3D

Comme pour le modèle MedImageParse, MedImageParse 3D utilise une combinaison d’une invite de texte et d’une image médicale pour créer un masque de segmentation. Toutefois, contrairement à MedImageParse, le modèle MedImageParse 3D prend un volume 3D entier, un moyen courant de représenter la zone image pour les modalités d'imagerie transversales comme le scanner ou l'IRM, et génère le masque de segmentation tridimensionnel.

Conditions préalables

• Un abonnement Azure avec un moyen de paiement valide. Les abonnements Azure gratuits ou d’essai ne fonctionnent pas. Si vous ne disposez pas d’un abonnement Azure, commencez par créer un compte Azure payant.

• Un projet Azure AI Foundry.

• Les contrôles d’accès en fonction du rôle Azure (RBAC Azure) sont utilisés pour accorder l’accès aux opérations dans le portail Azure AI Foundry. Pour effectuer les étapes décrites dans cet article, votre compte d’utilisateur doit avoir le Rôle de développeur Azure AI sur le groupe de ressources. Pour plus d’informations sur les autorisations, consultez Contrôle d’accès en fonction du rôle sur le portail Azure AI Foundry.

Déployer le modèle sur un calcul managé

Le déploiement vers une solution d’inférence managée auto-hébergée vous permet de personnaliser et de contrôler tous les détails sur la façon dont le modèle est servi. Vous pouvez déployer le modèle à partir de sa carte de modèle dans l’interface utilisateur du catalogue d’Azure AI Foundry ou d’Azure Machine Learning Studio ou le déployer par programme.

Pour déployer le modèle via l’interface utilisateur :

1. Accédez au catalogue de modèles.

2. Recherchez le modèle et sélectionnez sa carte de modèle.

3. Dans la page de vue d’ensemble du modèle, sélectionnez Déployer.

4. Si vous avez la possibilité de choisir entre le déploiement standard et le déploiement à l’aide d’un calcul managé, sélectionnez Calcul managé.

5. 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.

6. Sélectionnez Déployer.

Pour déployer le modèle par programmation, consultez Comment déployer et inférer un déploiement de calcul managé avec du code.

Travaillez avec un modèle de segmentation

Dans cette section, vous consommez le modèle et vous effectuez des appels de base à celui-ci.

Utiliser l’API REST pour consommer le modèle

Utilisez le modèle en tant qu’API REST, à l’aide de requêtes GET simples ou en créant un client comme suit :

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

ml_client_workspace = MLClient.from_config(credential)

Dans la configuration du déploiement, vous pouvez choisir une méthode d’authentification. Cet exemple utilise l’authentification basée sur des jetons d’Azure Machine Learning. Pour plus d’options d’authentification, consultez la page de documentation correspondante. En outre, 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.

Effectuer 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.

MedImageParse

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,
)

MedImageParse 3D

import base64
import json
import urllib.request
import matplotlib.pyplot as plt
import nibabel as nib
import tempfile
import os

# Replace with the path to your NIfTI input file
sample_image = "./examples/amos_0308.nii.gz"
with open(sample_image, "rb") as image_file:
    base64_image = base64.b64encode(image_file.read()).decode('utf-8')

# Prepare data payload
data = {
    "input_data": {
        "columns": [ "image", "text" ],
        "index": [ 0 ],
        "data": [
            [
                base64_image,
                "pancreas"
            ]
        ]
    }
}
data_json = json.dumps(data)
body = str.encode(data_json)

# Add your endpoint URL and API key
url = "<your-endpoint-url>"
api_key = "<your-api-key>"

headers = {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer ' + api_key
}

req = urllib.request.Request(url, body, headers)

# Make sure decode_base64_to_nifti() and plot_segmentation_masks() are defined above
try:
    response = urllib.request.urlopen(req)
    result = response.read()
    result_list = json.loads(result)

    # Extract and decode NIfTI segmentation output
    nifti_file_str = result_list[0]["nifti_file"]
    nifti_file_data = decode_base64_to_nifti(nifti_file_str)

    print(nifti_file_data.shape)
    plot_segmentation_masks(nifti_file_data)

except urllib.error.HTTPError as error:
    print("The request failed with status code: " + str(error.code))
    print(error.info())
    print(error.read().decode("utf8", 'ignore'))

Informations de référence sur l’API REST

Les modèles MedImageParse et MedImageParse 3D supposent une interaction simple à tour unique où une requête produit une seule 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 :

MedImageParse

Clé	Catégorie	Obligatoire/Par défaut	Descriptif
input_data	[object]	O	Un objet contenant la charge utile des données d’entrée

L’objet input_data contient les champs suivants :

Clé	Catégorie	Obligatoire/Par défaut	Valeurs autorisées	Descriptif
columns	list[string]	O	"image", "text"	Un objet contenant les chaînes mappant les données aux entrées passées au modèle.
index	integer	O	0 - 256	Nombre d’entrées passées au modèle. Vous êtes limité par la quantité de données qui peuvent être passées dans une même requête POST, qui dépend de la taille de vos images. Il est donc raisonnable de maintenir ce nombre à quelques dizaines.
data	list[list[string]]	O	""	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.

MedImageParse 3D

Clé	Catégorie	Obligatoire/Par défaut	Descriptif
input_data	[object]	Oui	Objet contenant les données d’entrée

L’objet input_data contient les champs suivants :

Clé	Catégorie	Obligatoire/Par défaut	Valeurs autorisées	Descriptif
columns	list[string]	Oui	"image", "text"	Un objet contenant les chaînes mappant les données aux entrées passées au modèle.
index	integer	Oui	0	Ce paramètre est utilisé lorsque plusieurs entrées sont passées au point de terminaison dans un appel. Le wrapper de point de terminaison de ce modèle n’utilise pas ce paramètre. Il doit donc être défini sur 0.
data	list[list[string]]	Oui	Image base64 + requête de texte	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 image chaîne est le volume d’entrée au format NIfTI encodé à l’aide de base64 et décodé en tant que chaîne utf-8. Le texte d’entrée est une chaîne contenant la cible (par exemple, l’organe) à segmenter.

Exemple de requête

MedImageParse

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 "]
    ]
  }
}

MedImageParse 3D

Demande de segmentation du pancréas

{
  "input_data": {
    "columns": [
      "image",
      "text"
    ],
    "index":[0],
    "data": [
      ["iVBORw0KGgoAAAAN...",
      "pancreas"]
    ]
  }
}

Schéma de réponse

MedImageParse

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é	Catégorie	Descriptif
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é	Catégorie	Descriptif
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.

MedImageParse 3D

La réponse est une liste d’objets. Chaque objet contient le résultat de segmentation pour une entrée. Le masque de segmentation est encodé en tant que chaîne Base64 à l’intérieur d’un objet JSON sérialisé sous la clé nifti_file.

Clé	Catégorie	Descriptif
nifti_file	ficelle	Chaîne au format JSON contenant le masque de segmentation NIfTI codé en base64

Exemple de réponse

MedImageParse

Réponse à une simple inférence demandant la segmentation de deux objets

[
  {
    "image_features": "{ 
    'data': '4oCwUE5HDQoa...',
    'shape': [2, 1024, 1024], 
    'dtype': 'uint8'}",
    "text_features": ['liver', 'pancreas']
  }
]

MedImageParse 3D

[
  {
    "nifti_file": "{\"data\": \"H4sIAAAAAAAE...\"}"
  }
]

Le nifti_file champ est un objet JSON stringified. Pour décoder :

import json
import base64
import tempfile
import nibabel as nib
import os

def decode_base64_to_nifti(base64_string: str):
    """
    Decode a Base64 string back to a NIfTI image.

    Args:
        base64_string (str): Base64 encoded string of NIfTI image, wrapped in a JSON string

    Returns:
        np.ndarray: Decoded NIfTI image data as a NumPy array
    """
    # Parse the inner JSON object to extract the 'data' field
    base64_string = json.loads(base64_string)["data"]

    # Decode the Base64 string to raw bytes
    byte_data = base64.b64decode(base64_string)

    # Write the decoded bytes to a temporary .nii.gz file
    with tempfile.NamedTemporaryFile(suffix='.nii.gz', delete=False) as temp_file:
        temp_file.write(byte_data)     # Write bytes to file
        temp_file.flush()              # Ensure it's fully written to disk
        nifti_image = nib.load(temp_file.name)  # Load the image with nibabel

    # Clean up the temporary file to avoid clutter
    os.unlink(temp_file.name)

    # Return the image as a NumPy array
    return nifti_image.get_fdata()

Pour tracer le masque de segmentation

import matplotlib.pyplot as plt

def plot_segmentation_masks(segmentation_masks):
    """
    Plot a series of 2D slices from a 3D segmentation mask volume.
    Only slices with non-zero masks are displayed.

    Args:
        segmentation_masks (np.ndarray): A 3D NumPy array of shape (H, W, D),
                                         where D is the number of slices.
    """
    index = 1
    plt.figure(figsize=(15, 15))

    # Loop through each slice (along the depth axis)
    for i in range(segmentation_masks.shape[2]):
        # Only show slices that contain non-zero segmentation
        if segmentation_masks[:, :, i].sum() > 0:
            plt.subplot(4, 4, index)  # Adjust grid size if needed
            plt.imshow(segmentation_masks[:, :, i], cmap='gray')
            plt.axis('off')
            index += 1

    plt.tight_layout()
    plt.show()

Formats d’entrée pris en charge

MedImageParse

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 la résolution des 1024x1024 pixels. Les images doivent être redimensionnées et rembourrées (si elles ont un rapport d’aspect 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.

MedImageParse 3D

L’API de modèle déployé prend en charge les volumes encodés au format NIfTI.

En apprendre 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 :

• Déploiement et utilisation de MedImageParse : découvrez comment déployer le modèle MedImageParse et l'intégrer à votre flux de travail.
• 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.

Contenu connexe

• CXRReportGen pour la génération de rapports fondés
• MedImageInsight pour la génération de rapports fondés