MedImageParse healthcare AI-modellen gebruiken voor segmentatie van medische afbeeldingen

Belangrijk

De AI-modellen voor gezondheidszorg zijn bedoeld voor onderzoek en modelontwikkeling. De modellen zijn niet ontworpen of bedoeld om te worden geïmplementeerd in klinische instellingen, noch voor gebruik bij de diagnose of behandeling van een gezondheids- of medische aandoening, en de prestaties van de individuele modellen voor dergelijke doeleinden zijn niet vastgesteld. U bent alleen verantwoordelijk en aansprakelijk voor elk gebruik van de AI-modellen voor gezondheidszorg, met inbegrip van de verificatie van uitvoer en integratie in een product of dienst die is bedoeld voor een medisch doel of om klinische besluitvorming, naleving van toepasselijke gezondheidszorgwetten en -voorschriften te informeren en eventuele benodigde goedkeuringen of goedkeuringen te verkrijgen.

In dit artikel leert u hoe u prompt-gebaseerde afbeeldingssegmentatiemodellen, MedImageParse en MedImageParse 3D, implementeert als online eindpunten voor realtime inferentie. U ziet ook hoe u eenvoudige aanroepen naar de API kunt uitgeven. De stappen die u uitvoert, zijn:

• Implementeer het model op een zelf-hostende beheerde berekening.
• Verleen machtigingen voor het eindpunt.
• Testgegevens verzenden naar het model, de resultaten ontvangen en interpreteren.

MedImageParse

MedImageParse

Biografische beeldanalyse is cruciaal voor detectie in velden zoals celbiologie, pathologie en radiologie. Traditioneel worden taken zoals segmentatie, detectie en herkenning van relevante objecten afzonderlijk behandeld, waardoor de algehele effectiviteit van afbeeldingsanalyse kan worden beperkt. MedImageParse unifieert deze taken echter door het parseren van afbeeldingen, door gezamenlijk segmentatie, detectie en herkenning uit te voeren op verschillende objecttypen en imaging-modaliteiten. Door de onderlinge afhankelijkheden tussen deze subtaken toe te passen, zoals de semantische labels van gesegmenteerde objecten, verbetert het model de nauwkeurigheid en maakt het nieuwe toepassingen mogelijk. Hiermee kunnen gebruikers bijvoorbeeld alle relevante objecten in een afbeelding segmenteren met behulp van een eenvoudige tekstprompt. Met deze methode hoeft u geen begrenzingsvakken handmatig op te geven voor elk object.

In de volgende afbeelding ziet u de conceptuele architectuur van het MedImageParse-model waarbij een insluitmodel voor afbeeldingen wordt uitgebreid met een taakaanpassingslaag om segmentatiemaskers en tekstbeschrijvingen te produceren.

Opmerkelijk is dat de segmentatiemaskers en tekstbeschrijvingen werden bereikt met behulp van alleen standaardsegmentatiegegevenssets, uitgebreid door labels in natuurlijke taal of beschrijvingen die zijn afgestemd op gevestigde medische object ontologieën. Deze aanpak verbeterde niet alleen de prestaties van afzonderlijke taken, maar bood ook een alles-in-één hulpmiddel voor een diagnostische afbeeldingsanalyse, waardoor de weg naar efficiëntere en nauwkeurige, op afbeeldingen gebaseerde biogene detectie mogelijk is.

MedImageParse 3D

MedImageParse 3D

Net als bij het MedImageParse-model gebruikt MedImageParse 3D een combinatie van een tekstprompt en een medische afbeelding om een segmentatiemasker te maken. In tegenstelling tot MedImageParse neemt het MedImageParse 3D-model echter een volledig 3D-volume in beslag, een veelgebruikte manier om het afbeeldingsgebied voor cross-sectionele imaging-modaliteiten zoals CT of MRI weer te geven en genereert het 3dimensionale segmentatiemasker.

Vereiste voorwaarden

• Een Azure-abonnement met een geldige betalingswijze. Gratis of proefversie van Azure-abonnementen werkt niet. Als u geen Azure-abonnement hebt, maakt u eerst een betaald Azure-account .

• Als u er nog geen hebt, maakt u een op een hub gebaseerd project.

• Op rollen gebaseerd toegangsbeheer van Azure (Azure RBAC) wordt gebruikt om toegang te verlenen tot bewerkingen in de Azure AI Foundry-portal. Als u de stappen in dit artikel wilt uitvoeren, moet aan uw gebruikersaccount de Azure AI Developer-rol voor de resourcegroep zijn toegewezen. Zie op rollen gebaseerd toegangsbeheer in de Azure AI Foundry-portal voor meer informatie over machtigingen.

Het model implementeren op een beheerd rekenproces

Met de implementatie van een zelf-hostende beheerde deductieoplossing kunt u alle details over hoe het model wordt geleverd aanpassen en beheren. U kunt het model implementeren vanuit de modelkaart in de catalogusgebruikersinterface van Azure AI Foundry of Azure Machine Learning Studio of het programmatisch implementeren.

Het model implementeren via de gebruikersinterface:

1. Ga naar de modelcatalogus.

2. Zoek naar het model en selecteer de bijbehorende modelkaart.

3. Selecteer Implementeren op de overzichtspagina van het model.

4. Als u de optie krijgt om te kiezen tussen serverloze API-implementatie en implementatie met behulp van een beheerde berekening, selecteert u Managed Compute.

5. Vul de details in het implementatievenster in.

   Opmerking

   Voor implementatie naar een zelf-hostende beheerde rekenkracht moet u voldoende quotum in uw abonnement hebben. Als u onvoldoende quotum beschikbaar hebt, kunt u onze tijdelijke quotumtoegang gebruiken door de optie te selecteren die ik wil gebruiken gedeeld quotum en ik bevestig dat dit eindpunt over 168 uur wordt verwijderd.

6. Selecteer Implementeren.

Als u het model programmatisch wilt implementeren, raadpleegt u Hoe u een beheerde rekenprocesimplementatie implementeert en deductie met code.

Werken met een segmentatiemodel

In deze sectie gebruikt u het model en voert u eenvoudige aanroepen naar het model uit.

REST API gebruiken om het model te gebruiken

Gebruik het model als een REST API, met behulp van eenvoudige GET-aanvragen of door een client als volgt te maken:

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

credential = DefaultAzureCredential()

ml_client_workspace = MLClient.from_config(credential)

In de implementatieconfiguratie kunt u een verificatiemethode kiezen. In dit voorbeeld wordt verificatie op basis van azure Machine Learning-tokens gebruikt. Zie de bijbehorende documentatiepagina voor meer verificatieopties. De client wordt ook gemaakt op basis van een configuratiebestand dat automatisch wordt gemaakt voor virtuele Azure Machine Learning-machines (VM's). Meer informatie vindt u op de bijbehorende API-documentatiepagina.

Basisoproepen naar het model maken

Zodra het model is geïmplementeerd, gebruikt u de volgende code om gegevens te verzenden en segmentatiemaskers op te halen.

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

Referentie voor REST API

MedImageParse- en MedImageParse 3D-modellen gaan uit van een eenvoudige interactie met één beurt waarbij één aanvraag één antwoord produceert.

Aanvraagschema

De nettolading van de aanvraag is een tekenreeks met JSON-indeling met de volgende parameters:

MedImageParse

Sleutelcode	Typologie	Vereist/standaard	Beschrijving
input_data	[object]	Ja	Een object met de nettolading van invoergegevens

Het input_data object bevat de volgende velden:

Sleutelcode	Typologie	Vereist/standaard	Toegestane waarden	Beschrijving
columns	list[string]	Ja	"image", "text"	Een object met de tekenreeksen die gegevens toewijzen aan invoer die aan het model is doorgegeven.
index	integer	Ja	0 - 256	Het aantal invoer dat is doorgegeven aan het model. U bent beperkt door hoeveel gegevens kunnen worden doorgegeven in één POST-aanvraag, wat afhankelijk is van de grootte van uw afbeeldingen. Daarom is het redelijk om dit nummer in de tientallen te houden.
data	list[list[string]]	Ja	""	De lijst bevat de items die worden doorgegeven aan het model dat wordt gedefinieerd door de indexparameter. Elk item is een lijst met twee tekenreeksen. De volgorde wordt gedefinieerd door de columns parameter. De text tekenreeks bevat de prompttekst. De image tekenreeks is de bytes van de afbeelding die zijn gecodeerd met base64 en gedecodeerd als utf-8-tekenreeks. OPMERKING: De afbeelding moet worden aangepast aan 1024x1024 pixels voordat deze worden verzonden naar het model, waarbij de hoogte-breedteverhouding behouden blijft. Lege ruimte moet worden opgevuld met zwarte pixels. Zie het voorbeeldnotebook Segmentatie genereren voor een verscheidenheid aan imaging-modaliteiten voor een voorbeeld van het wijzigen van de grootte en opvullingscode. De invoertekst is een tekenreeks die meerdere zinnen bevat, gescheiden door het speciale teken &. Voorbeeld: tumor core & enhancing tumor & non-enhancing tumor. In dit geval zijn er drie zinnen, dus de uitvoer bestaat uit drie afbeeldingen met segmentatiemaskers.

MedImageParse 3D

Sleutelcode	Typologie	Vereist/standaard	Beschrijving
input_data	[object]	Ja	Een object met de invoergegevens

Het input_data object bevat de volgende velden:

Sleutelcode	Typologie	Vereist/standaard	Toegestane waarden	Beschrijving
columns	list[string]	Ja	"image", "text"	Een object met de tekenreeksen die gegevens toewijzen aan invoer die aan het model is doorgegeven.
index	integer	Ja	0	Deze parameter wordt gebruikt wanneer meerdere invoer wordt doorgegeven aan het eindpunt in één aanroep. De eindpunt-wrapper van dit model gebruikt deze parameter niet, dus moet deze worden ingesteld op 0.
data	list[list[string]]	Ja	Base64-afbeelding + tekstprompt	De lijst bevat de items die worden doorgegeven aan het model dat wordt gedefinieerd door de indexparameter. Elk item is een lijst met twee tekenreeksen. De volgorde wordt gedefinieerd door de columns parameter. De text tekenreeks bevat de prompttekst. De image tekenreeks is het invoervolume in NIfTI-indeling gecodeerd met base64 en gedecodeerd als utf-8-tekenreeks. De invoertekst is een tekenreeks die het doel (bijvoorbeeld orgaan) bevat dat moet worden gesegmenteerd.

Vraag om voorbeeld

MedImageParse

Segmentatie van alle cellen in een pathologieafbeelding aanvragen

{
  "input_data": {
    "columns": [
      "image",
      "text"
    ],
    "index":[0],
    "data": [
      ["iVBORw0KGgoAAAANSUhEUgAAAAIAAAACCAYAAABytg0kAAAAAXNSR0IArs4c6QAAAARnQU1BAACx\njwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAAbSURBVBhXY/gUoPS/fhfDfwaGJe///9/J8B8A\nVGwJ5VDvPeYAAAAASUVORK5CYII=\n",
      "neoplastic & inflammatory cells "]
    ]
  }
}

MedImageParse 3D

Aanvragen van segmentatie van de pancreas

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

Antwoordschema

MedImageParse

Nettolading van antwoorden is een lijst met tekenreeksen met JSON-indeling, die elk overeenkomen met een ingediende afbeelding. Elke tekenreeks bevat een segmentation_object object.

segmentation_object bevat de volgende velden:

Sleutelcode	Typologie	Beschrijving
image_features	segmentation_mask	Een object dat de segmentatiemaskers voor een bepaalde afbeelding weergeeft
text_features	list[string]	Lijst met tekenreeksen, één per verzonden tekenreeks, waarbij de segmentatiemaskers worden geclassificeerd in een van de 16 categorische segmentatiecategorieën elk: liver, , , lungkidneypancreasheart anatomiesbrain anatomieseye anatomiesvesselother organtumorinfectionother lesionfluid disturbanceother abnormalityhistology structureother

segmentation_mask bevat de volgende velden:

Sleutelcode	Typologie	Beschrijving
data	string	Een base64-gecodeerde NumPy-matrix die het gesegmenteerde segmentatiemasker met één hot bevat. Er kunnen meerdere exemplaren van objecten in de geretourneerde matrix zijn. Decoderen en gebruiken np.frombuffer om te deserialiseren. De matrix bevat een driedimensionale matrix. De grootte van de matrix is 1024x1024 (overeenkomend met de afmetingen van de invoerafbeelding), met de derde dimensie die het aantal opgegeven invoerzinnen vertegenwoordigt. Bekijk de opgegeven voorbeeldnotebooks voor decodering en gebruiksvoorbeelden .
shape	list[int]	Een lijst die de vorm van de matrix weergeeft (meestal [NUM_PROMPTS, 1024, 1024])
dtype	string	Een exemplaar van de NumPy-dtypeklasse die is geserialiseerd naar een tekenreeks. Beschrijft de gegevensverpakking in de gegevensmatrix.

MedImageParse 3D

Het antwoord is een lijst met objecten. Elk object bevat het segmentatieresultaat voor één invoer. Het segmentatiemasker wordt gecodeerd als een Base64-tekenreeks in een geserialiseerd JSON-object onder de sleutel nifti_file.

Sleutelcode	Typologie	Beschrijving
nifti_file	touw	JSON-geformatteerde tekenreeks met het NIfTI-segmentatiemasker met base64-codering

Voorbeeld van antwoord

MedImageParse

Antwoord op een eenvoudige deductie die segmentatie van twee objecten aanvraagt

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

MedImageParse 3D

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

Het nifti_file veld is een tekenreeks-JSON-object. Om te decoderen:

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

Segmentatiemasker tekenen

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

Ondersteunde invoerindelingen

MedImageParse

De geïmplementeerde model-API ondersteunt afbeeldingen die zijn gecodeerd in PNG-indeling. Voor optimale resultaten raden we u aan om niet-gecomprimeerde PNG's zonder verlies te gebruiken met RGB-afbeeldingen.

Zoals beschreven in de API-specificatie, accepteert het model alleen afbeeldingen in de resolutie van 1024x1024 pixels. Afbeeldingen moeten worden aangepast en opgevuld (als ze een niet-vierkante hoogte-breedteverhouding hebben).

Zie het notebook Voor het genereren van segmentatie voor een verscheidenheid aan imaging-modaliteiten voor technieken en voorbeeldcode handig voor het verzenden van afbeeldingen van verschillende grootten die zijn opgeslagen met behulp van verschillende indelingen voor imaging.

MedImageParse 3D

De geïmplementeerde model-API ondersteunt volumes die zijn gecodeerd in NIfTI-indeling.

Meer informatie uit voorbeelden

MedImageParse is een veelzijdig model dat kan worden toegepast op een breed scala aan taken en imaging-modaliteiten. Zie de volgende interactieve Python Notebooks voor meer voorbeelden:

• MedImageParse implementeren en gebruiken: leer hoe u het MedImageParse-model implementeert en integreert in uw werkstroom.
• Segmentatie genereren voor een verscheidenheid aan imaging-modaliteiten: begrijpen hoe u MedImageParse gebruikt om een groot aantal verschillende medische afbeeldingen te segmenteren en een aantal prompte technieken te leren.

Verwante inhoud

• CXRReportGen voor geaarde rapportgeneratie
• MedImageInsight voor het genereren van onderbouwde rapporten