MedImageParse healthcare AI-model gebruiken voor segmentatie van medische afbeeldingen
Belangrijk
Items die in dit artikel zijn gemarkeerd (preview) zijn momenteel beschikbaar als openbare preview. Deze preview wordt aangeboden zonder een service level agreement en we raden deze niet aan voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt. Zie Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews voor meer informatie.
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 MedImageParse implementeert als een online-eindpunt voor realtime deductie en een eenvoudige aanroep naar de API uitvoert. De stappen die u uitvoert, zijn:
- Implementeer het model op een zelf-hostende beheerde berekening.
- Verken machtigingen aan het eindpunt.
- Testgegevens verzenden naar het model, de resultaten ontvangen en interpreteren.
MedImageParse - op prompt gebaseerde segmentatie van medische afbeeldingen
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.
Vereisten
Als u het MedImageParse-model wilt gebruiken, hebt u de volgende vereisten nodig:
Een modelimplementatie
Implementatie naar een zelf-hostende beheerde compute
Het MedImageParse-model kan worden geïmplementeerd in onze zelf-hostende beheerde deductieoplossing, waarmee u alle details over hoe het model wordt geleverd, kunt aanpassen en beheren. U kunt het model implementeren via de catalogusgebruikersinterface (in AI Foundry of Azure Machine Learning-studio) of programmatisch implementeren.
Het model implementeren via de gebruikersinterface:
Ga naar de catalogus.
Zoek naar MedImageParse en selecteer de modelkaart.
Selecteer Implementeren op de overzichtspagina van het model.
Als u de optie krijgt om te kiezen tussen serverloze API-implementatie en implementatie met behulp van een beheerde berekening, selecteert u Managed Compute.
Vul de details in het implementatievenster in.
Notitie
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.
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 MedImageParse-segmentatiemodel 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 DeviceCodeCredential
credential = DefaultAzureCredential()
ml_client_workspace = MLClient.from_config(credential)
In de implementatieconfiguratie kunt u de verificatiemethode kiezen. In dit voorbeeld wordt verificatie op basis van azure Machine Learning-tokens gebruikt. Zie de bijbehorende documentatiepagina voor meer verificatieopties. Houd er ook rekening mee dat de client wordt 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.
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 REST API gebruiken
Het MedImageParse-model gaat 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:
| Sleutel | Type | Vereist/standaard | Beschrijving |
|---|---|---|---|
input_data |
[object] |
J | Een object met de nettolading van invoergegevens |
Het input_data object bevat de volgende velden:
| Sleutel | Type | Vereist/standaard | Toegestane waarden | Beschrijving |
|---|---|---|---|---|
columns |
list[string] |
J | "image", "text" |
Een object met de tekenreeksen die gegevens toewijzen aan invoer die aan het model is doorgegeven. |
index |
integer |
J | 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]] |
J | "" | 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. |
Aanvraagvoorbeeld
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 "]
]
}
}
Antwoordschema
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:
| Sleutel | Type | Description |
|---|---|---|
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, , , eye anatomieslungkidneypancreasheart anatomiesbrain anatomiesvesselother organtumorinfectionother lesionfluid disturbanceother abnormalityhistology structureother |
segmentation_mask bevat de volgende velden:
| Sleutel | Type | Description |
|---|---|---|
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. |
Responsvoorbeeld
Een eenvoudige deductie die segmentatie van twee objecten aanvraagt
[
{
"image_features": "{
'data': '4oCwUE5HDQoa...',
'shape': [2, 1024, 1024],
'dtype': 'uint8'}",
"text_features": ['liver', 'pancreas']
}
]
Ondersteunde afbeeldingsindelingen
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 1024x1024pixels. Afbeeldingen moeten worden aangepast en opgevuld (in het geval van een niet-vierkante hoogte-breedteverhouding).
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.
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:
Aan de slag
- MedImageParse implementeren en gebruiken: leer hoe u het MedImageParse-model implementeert en integreert in uw werkstroom.
Geavanceerde deductietechnieken en -steekproeven
- 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.