Så här använder du Ai-modeller för MedImageParse-sjukvård för segmentering av medicinska bilder

Viktigt!

AI-modellerna för hälso- och sjukvård är avsedda för forsknings- och modellutvecklingsutforskning. Modellerna är inte utformade eller avsedda att distribueras i kliniska miljöer som de är eller för användning vid diagnos eller behandling av något hälsotillstånd eller medicinskt tillstånd, och de enskilda modellernas prestationer för sådana ändamål har inte fastställts. Du bär ensamt ansvar för all användning av AI-modeller för hälso- och sjukvård, inklusive verifiering av utdata och införlivande i alla produkter eller tjänster som är avsedda för ett medicinskt ändamål eller för att informera om kliniskt beslutsfattande, efterlevnad av tillämpliga hälso- och sjukvårdslagar och föreskrifter och erhålla nödvändiga godkännanden eller godkännanden.

I den här artikeln får du lära dig hur du implementerar promptbaserade bildsegmenteringsmodeller, MedImageParse och MedImageParse 3D, som onlineslutpunkter för realtidsinferenstjänster. Du ser också hur du utfärdar grundläggande anrop till API:et. De steg du utför är:

• Distribuera modellen till en lokalt installerad hanterad beräkning.
• Bevilja behörigheter till slutpunkten.
• Skicka testdata till modellen, ta emot och tolka resultat.

MedImageParse

MedImageParse

Biomedicinsk bildanalys är avgörande för upptäckt inom områden som cellbiologi, patologi och radiologi. Traditionellt behandlas uppgifter som segmentering, identifiering och igenkänning av relevanta objekt separat, vilket kan begränsa bildanalysens övergripande effektivitet. MedImageParse förenar dock dessa uppgifter genom bildparsning genom att gemensamt utföra segmentering, identifiering och igenkänning mellan många objekttyper och bildmodaliteter. Genom att tillämpa beroendena mellan dessa underaktiviteter, till exempel semantiska etiketter för segmenterade objekt, förbättrar modellen noggrannheten och möjliggör nya program. Det gör det till exempel möjligt för användare att segmentera alla relevanta objekt i en bild med hjälp av en enkel textprompt. Den här metoden eliminerar behovet av att manuellt ange avgränsningsrutor för varje objekt.

Följande bild visar den konceptuella arkitekturen i MedImageParse-modellen där en bildinbäddningsmodell utökas med ett aktivitetsanpassningslager för att producera segmenteringsmasker och textbeskrivningar.

Anmärkningsvärt nog uppnåddes segmenteringsmasker och textbeskrivningar genom att endast använda standardsegmenteringsdatauppsättningar, förstärkta med naturligt språketiketter eller beskrivningar som harmoniserades med etablerade biomedicinska objekt ontologier. Den här metoden förbättrade inte bara prestandan för enskilda uppgifter utan erbjöd också ett allt-i-ett-verktyg för biomedicinsk bildanalys, vilket banar väg för effektivare och mer exakta bildbaserade biomedicinska identifieringar.

MedImageParse 3D

MedImageParse 3D

I likhet med MedImageParse-modellen använder MedImageParse 3D en kombination av en textprompt och en medicinsk bild för att skapa en segmenteringsmask. Men till skillnad från MedImageParse tar MedImageParse 3D-modellen in en hel 3D-volym – ett vanligt sätt att representera det avbildningsområdet för tvärsnittsavbildningsmodaliteter som CT eller MRI – och genererar den tredimensionella segmenteringsmasken.

Förutsättningar

• En Azure-prenumeration med en giltig betalningsmetod. Kostnadsfria azure-prenumerationer eller utvärderingsprenumerationer fungerar inte. Om du inte har en Azure-prenumeration skapar du ett betalt Azure-konto för att börja.

• Om du inte har något skapar du ett hubbbaserat projekt.

• Rollbaserade åtkomstkontroller i Azure (Azure RBAC) används för att ge åtkomst till åtgärder i Azure AI Foundry-portalen. Om du vill utföra stegen i den här artikeln måste ditt användarkonto tilldelas rollen Azure AI Developer i resursgruppen. Mer information om behörigheter finns i Rollbaserad åtkomstkontroll i Azure AI Foundry-portalen.

Distribuera modellen till en hanterad beräkning

Med distributionen till en självhanterad hanterad slutsatsdragningslösning kan du anpassa och kontrollera all information om hur modellen hanteras. Du kan distribuera modellen från dess modellkort i kataloggränssnittet för Azure AI Foundry eller Azure Machine Learning Studio eller distribuera den programmatiskt.

Så här distribuerar du modellen via användargränssnittet:

1. Gå till modellkatalogen.

2. Sök efter modellen och välj dess modellkort.

3. På modellens översiktssida väljer du Distribuera.

4. Om du får möjlighet att välja mellan serverlös API-distribution och distribution med hjälp av en hanterad beräkning väljer du Hanterad beräkning.

5. Fyll i informationen i distributionsfönstret.

   Anmärkning

   För distribution till en lokalt installerad hanterad beräkning måste du ha tillräckligt med kvot i din prenumeration. Om du inte har tillräckligt med tillgänglig kvot kan du använda vår tillfälliga kvotåtkomst genom att välja alternativet Jag vill använda delad kvot och jag bekräftar att slutpunkten tas bort om 168 timmar.

6. Välj Distribuera.

Information om hur du distribuerar modellen programmatiskt finns i Så här distribuerar och härleder du en hanterad beräkningsdistribution med kod.

Arbeta med en segmenteringsmodell

I det här avsnittet använder du modellen och gör grundläggande anrop till den.

Använda REST API för att använda modellen

Använd modellen som ett REST-API, med enkla GET-begäranden eller genom att skapa en klient på följande sätt:

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

credential = DefaultAzureCredential()

ml_client_workspace = MLClient.from_config(credential)

I distributionskonfigurationen får du välja en autentiseringsmetod. I det här exemplet används tokenbaserad autentisering i Azure Machine Learning. Fler autentiseringsalternativ finns på motsvarande dokumentationssida. Dessutom skapas klienten från en konfigurationsfil som skapas automatiskt för virtuella Azure Machine Learning-datorer (VM). Läs mer på motsvarande API-dokumentationssida.

Gör grundläggande anrop till modellen

När modellen har distribuerats använder du följande kod för att skicka data och hämta segmenteringsmasker.

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

Referens för REST API

MedImageParse- och MedImageParse 3D-modeller förutsätter en enkel interaktion med en enda tur där en begäran genererar ett svar.

Schema för begäran

Nyttolasten för begäran är en JSON-formaterad sträng som innehåller följande parametrar:

MedImageParse

Nyckel	Typ	Obligatoriskt/standard	Beskrivning
input_data	[object]	Y	Ett objekt som innehåller nyttolasten för indata

Objektet input_data innehåller följande fält:

Nyckel	Typ	Obligatoriskt/standard	Tillåtna värden	Beskrivning
columns	list[string]	Y	"image", "text"	Ett objekt som innehåller strängarna som mappar data till indata som skickas till modellen.
index	integer	Y	0 - 256	Antal indata som skickats till modellen. Du begränsas av hur mycket data som kan skickas i en enda POST-begäran, vilket beror på storleken på dina bilder. Därför är det rimligt att behålla det här antalet i dussintals.
data	list[list[string]]	Y	""	Listan innehåller de objekt som skickas till modellen som definieras av indexparametern. Varje objekt är en lista med två strängar. Ordningen definieras av parametern columns . Strängen text innehåller prompttexten. Strängen image är de bildbyte som kodas med base64 och avkodas som utf-8-sträng. Obs! Bilden bör ändras till 1024x1024 bildpunkter innan den skickas till modellen, vilket bevarar proportionerna. Tomt utrymme ska vara vadderat med svarta bildpunkter. Se exempelanteckningsboken Generera segmentering för en mängd olika bildmodaliteter för ett exempel på storleksändring och utfyllnadskod. Indatatexten är en sträng som innehåller flera meningar avgränsade med specialtecknet &. Till exempel: tumor core & enhancing tumor & non-enhancing tumor. I det här fallet finns det tre meningar, så utdata består av tre bilder med segmenteringsmasker.

MedImageParse 3D

Nyckel	Typ	Obligatoriskt/standard	Beskrivning
input_data	[object]	Ja	Ett objekt som innehåller indata

Objektet input_data innehåller följande fält:

Nyckel	Typ	Obligatoriskt/standard	Tillåtna värden	Beskrivning
columns	list[string]	Ja	"image", "text"	Ett objekt som innehåller strängarna som mappar data till indata som skickas till modellen.
index	integer	Ja	0	Den här parametern används när flera indata skickas till slutpunkten i ett anrop. Den här modellens slutpunktsomslutning använder inte den här parametern, så den bör vara inställd på 0.
data	list[list[string]]	Ja	Base64-bild + textprompt	Listan innehåller de objekt som skickas till modellen som definieras av indexparametern. Varje objekt är en lista med två strängar. Ordningen definieras av parametern columns . Strängen text innehåller prompttexten. Strängen image är indatavolymen i NIfTI-format som kodas med base64 och avkodas som utf-8-sträng. Indatatexten är en sträng som innehåller målet (till exempel organ) som ska segmenteras.

Exempel på begäran

MedImageParse

Begära segmentering av alla celler i en patologibild

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

MedImageParse 3D

Begära segmentering av bukspottkörteln

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

Svarsschema

MedImageParse

Svarsnyttolast är en lista över JSON-formaterade strängar som var och en motsvarar en skickad bild. Varje sträng innehåller ett segmentation_object objekt.

segmentation_object innehåller följande fält:

Nyckel	Typ	Beskrivning
image_features	segmentation_mask	Ett objekt som representerar segmenteringsmaskerna för en viss bild
text_features	list[string]	Lista över strängar, en per varje skickad textsträng, som klassificerar segmenteringsmaskerna i någon av 16 biomedicinska segmenteringskategorier vardera: , , , , , , liver, lungkidney, , pancreas, heart anatomies, brain anatomies, eye anatomies, vessel, other organ, , tumorinfectionother lesionfluid disturbanceother abnormalityhistology structureother

segmentation_mask innehåller följande fält:

Nyckel	Typ	Beskrivning
data	string	En base64-kodad NumPy-matris som innehåller en kodad segmenteringsmask med en frekvent kodning. Det kan finnas flera instanser av objekt i den returnerade matrisen. Avkoda och använd np.frombuffer för att deserialisera. Matrisen innehåller en tredimensionell matris. Matrisens storlek är 1024x1024 (matchar indatabildens dimensioner), där den tredje dimensionen representerar antalet indatameningar som anges. Se de angivna exempelanteckningsböckerna för avkodning och användningsexempel.
shape	list[int]	En lista som representerar matrisens form (vanligtvis [NUM_PROMPTS, 1024, 1024])
dtype	string	En instans av dtype-klassen NumPy serialiserades till en sträng. Beskriver datapackningen i datamatrisen.

MedImageParse 3D

Svaret är en lista över objekt. Varje objekt innehåller segmenteringsresultatet för en indata. Segmenteringsmasken kodas som en Base64-sträng inuti ett serialiserat JSON-objekt under nyckeln nifti_file.

Nyckel	Typ	Beskrivning
nifti_file	snöre	JSON-formaterad sträng som innehåller den base64-kodade NIfTI-segmenteringsmasken

Svarsexempel

MedImageParse

Svar på en enkel slutsatsdragning som begär segmentering av två objekt

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

MedImageParse 3D

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

Fältet nifti_file är ett strängifierat JSON-objekt. Så här avkodar du:

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

Så här ritar du segmenteringsmask

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

Indataformat som stöds

MedImageParse

Det distribuerade modell-API:et stöder bilder som kodats i PNG-format. För optimala resultat rekommenderar vi att du använder okomprimerade/förlustfria PNG:er med RGB-bilder.

Enligt beskrivningen i API-specifikationen accepterar modellen endast bilder i bildpunkternas upplösning 1024x1024 . Bilder måste storleksändras och vadderas (om de har en proportion som inte är kvadratisk).

I notebook-filen Generating Segmentation for a Variety of Imaging Modalities (Generera segmentering för en mängd olika bildmodaliteter ) finns tekniker och exempelkod som är användbara för att skicka bilder av olika storlekar som lagras med olika biomedicinska bildformat.

MedImageParse 3D

Det distribuerade modell-API:et stöder volymer som kodats i NIfTI-format.

Läs mer från exempel

MedImageParse är en mångsidig modell som kan tillämpas på en mängd olika uppgifter och metoder för avbildning. Fler exempel finns i följande interaktiva Python Notebooks:

• Distribuera och använda MedImageParse: Lär dig hur du distribuerar MedImageParse-modellen och integrerar den i arbetsflödet.
• Generera segmentering för en mängd olika avbildningsmodaliteter: Förstå hur du använder MedImageParse för att segmentera en mängd olika medicinska bilder och lära dig några frågande tekniker.

Relaterat innehåll

• CXRReportGen för jordad rapportgenerering
• MedImageInsight för grundad rapportgenerering