Uso de modelos de inteligencia artificial de salud de MedImageParse para la segmentación de imágenes médicas

Importante

Los modelos de inteligencia artificial sanitaria están diseñados para la investigación y la exploración del desarrollo de modelos. Los modelos no están diseñados ni diseñados para implementarse en la configuración clínica tal como está ni para su uso en el diagnóstico o tratamiento de ninguna enfermedad o salud, y no se han establecido los modelos individuales para tales fines. Usted asume responsabilidad exclusiva y responsabilidad por cualquier uso de los modelos de inteligencia artificial sanitaria, incluida la comprobación de salidas e incorporación a cualquier producto o servicio destinado a un propósito médico o a informar a la toma de decisiones clínicas, el cumplimiento de las leyes y reglamentos sanitarios aplicables, y obtener los permisos o aprobaciones necesarios.

En este artículo, aprenderá a implementar modelos de segmentación de imágenes basadas en mensajes, MedImageParse y MedImageParse 3D, como puntos de conexión en línea para la inferencia en tiempo real. También verá cómo emitir llamadas básicas a la API. Los pasos son:

• Implemente el modelo en un proceso administrado autohospedado.
• Conceder permisos al punto de conexión.
• Envíe datos de prueba al modelo, reciba e interprete los resultados.

MedImageParse

MedImageParse

El análisis biomédico de imágenes es fundamental para el descubrimiento en campos como la biología celular, la patología y la radiología. Tradicionalmente, tareas como la segmentación, la detección y el reconocimiento de objetos relevantes se abordan por separado, lo que puede limitar la eficacia general del análisis de imágenes. Sin embargo, MedImageParse unifica estas tareas mediante el análisis sintáctico de imágenes, llevando a cabo conjuntamente la segmentación, la detección y el reconocimiento a través de numerosos tipos de objetos y modalidades de creación de imágenes. Al aplicar las interdependencias entre estas subtareas, como las etiquetas semánticas de los objetos segmentados, el modelo mejora la precisión y permite nuevas aplicaciones. Por ejemplo, permite a los usuarios segmentar todos los objetos relevantes de una imagen, usando un simple mensaje de texto. Este enfoque elimina la necesidad de especificar manualmente los cuadros delimitadores de cada objeto.

La siguiente imagen muestra la arquitectura conceptual del modelo MedImageParse, en el que un modelo de inserción de imágenes se complementa con una capa de adaptación de tareas para generar máscaras de segmentación y descripciones textuales.

Cabe destacar que las máscaras de segmentación y las descripciones textuales se lograron usando únicamente conjuntos de datos de segmentación estándar, aumentados con etiquetas de lenguaje natural, o descripciones armonizadas con ontologías de objetos biomédicos establecidas. Este enfoque no solo mejoró el rendimiento de las tareas individuales, sino que también ofreció una herramienta todo en uno para el análisis de imágenes biomédicas, allanando el camino para un descubrimiento biomédico basado en imágenes más eficiente y preciso.

MedImageParse 3D

MedImageParse 3D

De forma similar al modelo MedImageParse, MedImageParse 3D usa una combinación de un mensaje de texto y una imagen médica para crear una máscara de segmentación. Sin embargo, a diferencia de MedImageParse, el modelo MedImageParse 3D toma un volumen 3D completo, una forma común de representar el área imaginada para las modalidades de imágenes transversales, como TAC o RMN, y genera la máscara de segmentación tridimensional.

Prerrequisitos

• Una suscripción de Azure con un método de pago válido. Las suscripciones gratuitas o de evaluación de Azure no funcionarán. Si no tiene una suscripción de Azure, cree una cuenta de Azure de pago para comenzar.

• Un proyecto de Azure AI Foundry.

• Los controles de acceso basados en roles de Azure (Azure RBAC) se utilizan para otorgar acceso a las operaciones en el portal de Azure AI Foundry. Para realizar los pasos descritos en este artículo, la cuenta de usuario debe tener asignado el rol Desarrollador de Azure AI en el grupo de recursos. Para más información sobre los permisos, consulte el control de acceso basado en roles en el portal de Azure AI Foundry.

Desplegar el modelo en un recurso de computación gestionado

La implementación en una solución de inferencia administrada autohospedada permite personalizar y controlar todos los detalles sobre cómo se sirve el modelo. Puede implementar el modelo desde su tarjeta de modelo en la interfaz de usuario de catálogo de Azure AI Foundry o Azure Machine Learning Studio o implementarlo mediante programación.

Para implementar el modelo a través de la interfaz de usuario:

1. Vaya al catálogo de modelos.

2. Busque el modelo y seleccione su tarjeta de modelo.

3. En la página de información general del modelo, seleccione Implementar.

4. Si se proporciona la opción de elegir entre la implementación estándar y la implementación mediante un proceso administrado, seleccione Proceso administrado.

5. Rellene los detalles en la ventana de implementación.

   Nota:

   Para la implementación en un proceso administrado autohospedado, se debe tener suficiente cuota en la suscripción. Si no tuviera suficiente cuota disponible, use el acceso de cuota temporal seleccionando la opción Quiero usar la cuota compartida y confirmo que este punto de conexión se eliminará en 168 horas.

6. Seleccione Implementar.

Para implementar el modelo mediante programación, consulte Implementación e inferencia de una implementación de proceso administrada con código.

Trabajar con un modelo de segmentación

En esta sección, se consume el modelo y se le hacen llamadas básicas.

Uso de la API de REST para consumir el modelo

Consume el modelo como una API REST, mediante sencillas solicitudes GET o creando un cliente de la siguiente manera:

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

credential = DefaultAzureCredential()

ml_client_workspace = MLClient.from_config(credential)

En la configuración de implementación, puede elegir un método de autenticación. En este ejemplo se usa la autenticación basada en tokens de Azure Machine Learning. Para obtener más opciones de autenticación, consulte la página de documentación correspondiente. Además, el cliente se crea a partir de un archivo de configuración que se crea automáticamente para máquinas virtuales (VM) de Azure Machine Learning. Obtenga más información en la página de documentación de la API correspondiente.

Realización de llamadas básicas al modelo

Una vez implementado el modelo, use el siguiente código para enviar datos y recuperar máscaras de segmentación.

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

Referencia de la API REST

Los modelos MedImageParse y MedImageParse 3D asumen una interacción simple de un solo turno donde una solicitud genera una respuesta.

Esquema de solicitud

La carga de solicitud es una cadena con formato JSON que contiene los parámetros siguientes:

MedImageParse

Clave	Tipo	Obligatorio/predeterminado	Descripción
input_data	[object]	Y	Un objeto que contiene la carga de datos de entrada

El input_data objeto contiene los campos siguientes:

Clave	Tipo	Obligatorio/predeterminado	Valores permitidos	Descripción
columns	list[string]	S	"image", "text"	Objeto que contiene las cadenas que asignan datos a las entradas que se pasan al modelo.
index	integer	S	0 - 256	Recuento de entradas pasadas al modelo. Está limitado por la cantidad de datos que se pueden pasar en una sola solicitud POST, que depende del tamaño de las imágenes. Por lo tanto, es razonable mantener este número en las docenas.
data	list[list[string]]	Y	""	La lista contiene los elementos pasados al modelo definido por el parámetro de índice. Cada elemento es una lista de dos cadenas. El orden se define mediante el parámetro columns. La cadena text contiene el texto del mensaje. La cadena image son los bytes de la imagen codificados mediante base64 y decodificados como cadena UTF-8. NOTA: la imagen debe redimensionarse a 1024x1024 píxeles antes de enviarla al modelo, conservando la relación de aspecto. El espacio vacío debe rellenarse con píxeles negros. Consulte el cuaderno de ejemplo Generación de segmentación para una variedad de modalidades de imagen para ver un ejemplo de código de redimensionamiento y relleno. El texto de entrada es una cadena que contiene varias oraciones separadas por el carácter especial &. Por ejemplo: tumor core & enhancing tumor & non-enhancing tumor. En este caso, hay tres oraciones, por lo que la salida consta de tres imágenes con máscaras de segmentación.

MedImageParse 3D

Clave	Tipo	Obligatorio/predeterminado	Descripción
input_data	[object]	Sí	Objeto que contiene los datos de entrada

El input_data objeto contiene los campos siguientes:

Clave	Tipo	Obligatorio/predeterminado	Valores permitidos	Descripción
columns	list[string]	Sí	"image", "text"	Objeto que contiene las cadenas que asignan datos a las entradas que se pasan al modelo.
index	integer	Sí	0	Este parámetro se usa cuando se pasan varias entradas al punto de conexión en una llamada. La envoltura de punto final de este modelo no usa este parámetro, por lo que debe configurarse en 0.
data	list[list[string]]	Sí	Imagen base64 + mensaje de texto	La lista contiene los elementos pasados al modelo definido por el parámetro de índice. Cada elemento es una lista de dos cadenas. El orden se define mediante el parámetro columns. La cadena text contiene el texto del mensaje. La image cadena es el volumen de entrada en formato NIfTI codificado mediante base64 y descodificado como cadena utf-8. El texto de entrada es una cadena que contiene el destino (por ejemplo, órgano) que se va a segmentar.

Ejemplo de solicitud

MedImageParse

Solicitud de segmentación de todas las células en una imagen patológica

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

MedImageParse 3D

Solicitud de segmentación del páncreas

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

Esquema de respuesta

MedImageParse

La carga útil de la respuesta es una lista de cadenas con formato JSON, cada una de las cuales corresponde a una imagen enviada. Cada cadena contiene un objeto segmentation_object.

segmentation_object contiene los siguientes campos:

Clave	Tipo	Descripción
image_features	segmentation_mask	Un objeto que representa las máscaras de segmentación de una imagen determinada
text_features	list[string]	Lista de cadenas, una por cada cadena de texto enviada, que clasifica las máscaras de segmentación en una de las 16 categorías de segmentación biomédica: 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 contiene los siguientes campos:

Clave	Tipo	Descripción
data	string	Una matriz NumPy codificada en base64 que contiene la máscara de segmentación codificada en un punto. Podría haber varias instancias de objetos en la matriz devuelta. Descodifique y use np.frombuffer para deserializar. La matriz contiene una matriz tridimensional. El tamaño de la matriz es 1024x1024 (que coincide con las dimensiones de la imagen de entrada), y la tercera dimensión representa el número de oraciones de entrada proporcionadas. Consulte los cuadernos de ejemplo proporcionados para obtener ejemplos de descodificación y uso.
shape	list[int]	Una lista que representa la forma de la matriz (normalmente [NUM_PROMPTS, 1024, 1024])
dtype	string	Una instancia de la clase NumPy dtype serializada en una cadena. Describe el empaquetado de datos en la matriz de datos.

MedImageParse 3D

La respuesta es una lista de objetos. Cada objeto contiene el resultado de segmentación de una entrada. La máscara de segmentación se codifica como una cadena Base64 dentro de un objeto JSON serializado bajo la clave nifti_file.

Clave	Tipo	Descripción
nifti_file	cuerda / cadena	Cadena con formato JSON que contiene la máscara de segmentación NIfTI codificada en base64

Ejemplo de respuesta

MedImageParse

Respuesta a una inferencia simple que solicita la segmentación de dos objetos

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

MedImageParse 3D

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

El nifti_file campo es un objeto JSON con cadena. Para descodificar:

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

Para trazar la máscara de segmentación

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

Formatos de entrada admitidos

MedImageParse

La API de modelo implementada admite imágenes codificadas en formato PNG. Para obtener resultados óptimos, se recomienda usar PNG sin comprimir o sin pérdida con imágenes RGB.

Como se describe en la especificación de API, el modelo solo acepta imágenes en la resolución de 1024x1024 píxeles. Las imágenes deben redimensionarse y almohadillarse (si tienen una relación de aspecto no cuadrada).

Consulte el cuaderno Generación de segmentación para una variedad de modalidades de creación de imágenes para ver técnicas y ejemplos de código útiles para enviar imágenes de varios tamaños almacenadas usando varios formatos de imagen biomédica.

MedImageParse 3D

La API del modelo implementado admite volúmenes codificados en formato NIfTI.

Más información en ejemplos

MedImageParse es un modelo versátil que se puede aplicar a una amplia gama de tareas y modalidades de creación de imágenes. Para obtener más ejemplos, consulte los siguientes cuadernos interactivos de Python:

• Implementación y uso de MedImageParse: aprenda a implementar el modelo MedImageParse e integrarlo en el flujo de trabajo.
• Generación de segmentación para una variedad de modalidades de creación de imágenes: comprenda cómo usar MedImageParse para segmentar una amplia variedad de diferentes imágenes médicas y aprenda algunas técnicas de solicitud.

Contenido relacionado

• CXRReportGen para la generación de informes con base
• MedImageInsight para la generación de informes fundamentados