Main Content

Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

Clasificación de aprendizaje profundo de imágenes grandes de multiresolución

En este ejemplo se muestra cómo entrenar una red neuronal profunda Inception-v3 para clasificar imágenes de diapositivas enteras (WSI) multiresolución que no caben en la memoria.

El ejemplo muestra cómo entrenar una red de clasificación de tumores Inception-v3 y también proporciona una red Inception-v3 previamente entrenada. Si decide entrenar la red Inception-v3, se recomienda utilizar una GPU NVIDIA™ compatible con CUDA con capacidad de computación 3.0 o superior. El uso de una GPU requiere Parallel Computing Toolbox™.

Introducción

La única manera definitiva de diagnosticar el cáncer de mama es examinando las muestras de tejido recogidas de la biopsia o la cirugía. Las muestras se preparan comúnmente con hematoxilina y eosina (H&E) tinción para aumentar el contraste de las estructuras en el tejido. Tradicionalmente, los patólogos examinan el tejido en diapositivas de vidrio bajo un microscopio para detectar el tejido tumoral. El diagnóstico lleva tiempo, ya que los patólogos deben inspeccionar a fondo una diapositiva entera con un aumento cercano. Además, es posible que los patólogos no noten tumores pequeños. Los métodos de aprendizaje profundo tienen como objetivo automatizar la detección del tejido tumoral, ahorrando tiempo y mejorando la tasa de detección de tumores pequeños.

Los métodos de aprendizaje profundo para la clasificación tumoral se basan en la patología digital, en la que se crean imágenes y digitalizan diapositivas de tejido entero. Los WSI resultantes tienen una resolución extremadamente alta. Los WSI se almacenan con frecuencia en un archivo multiresolución para facilitar la visualización, navegación y procesamiento de las imágenes.

La lectura de WSI es un desafío porque las imágenes no se pueden cargar como un todo en la memoria y, por lo tanto, requieren técnicas de procesamiento de imágenes desintegradas. Image Processing Toolbox™ objetos pueden almacenar y procesar este tipo de imagen multiresolución grande. los objetos pueden preparar parches de entrenamiento de a para alimentarse en una red neuronal.bigimagebigimageDatastorebigimage

En este ejemplo se muestra cómo entrenar una red de aprendizaje profundo para clasificar tumores en imágenes multiresolución muy grandes mediante y .bigimagebigimageDatastore El ejemplo presenta resultados de clasificación como mapas de calor que representan la probabilidad de que ese tejido local sea tumoroso. La localización de las regiones tumorales permite a los patólogos médicos investigar regiones específicas e identificar rápidamente tumores de cualquier tamaño en una imagen.

Descargar datos de formación

En este ejemplo se utilizan los WSI del desafío Camelyon16 [ ].1 Los datos de este desafío contienen un total de 400 WSI de ganglios linfáticos de dos fuentes independientes, separadas en 270 imágenes de entrenamiento y 130 imágenes de prueba. Los WSI se almacenan como archivos TIF en un formato despojado con una estructura piramidal de 11 niveles.

los objetos advierten cuando las imágenes contienen formatos despojados porque este formato tarda en procesarse.bigimage Para evitar mostrar advertencias en la ventana de comandos, desactive la advertencia mientras se ejecuta el ejemplo y restaure el estado de advertencia al finalizar.

warningState = warning('off','images:bigimage:singleStripTiff'); c = onCleanup(@()warning(warningState));

El conjunto de datos de entrenamiento consta de 159 WSI de ganglios linfáticos normales y 111 WSI de ganglios linfáticos con tumor y tejido sano. Por lo general, el tejido tumoral es una pequeña fracción del tejido sano. Las coordenadas de la verdad del suelo de los límites de la lesión acompañan las imágenes del tumor.

El tamaño de cada archivo de entrenamiento es de aproximadamente 2 GB. Si no desea descargar el conjunto de datos de entrenamiento o entrenar la red, vaya directamente a la sección de este ejemplo.Descargar y preprocesar datos de pruebas

Cree un directorio para almacenar el conjunto de datos de entrenamiento.

trainingImageDir = fullfile(tempdir,'Camelyon16','training'); if ~exist(trainingImageDir,'dir')     mkdir(trainingImageDir);     mkdir(fullfile(trainingImageDir,'normal'));     mkdir(fullfile(trainingImageDir,'tumor'));     mkdir(fullfile(trainingImageDir,'lesion_annotations')); end  trainNormalDataDir = fullfile(trainingImageDir,'normal'); trainTumorDataDir = fullfile(trainingImageDir,'tumor'); trainTumorAnnotationDir = fullfile(trainingImageDir,'lesion_annotations');

Para descargar los datos de entrenamiento, vaya a la Camelyon17 y haga clic en el primer enlace "CAMELYON16 data set". Abra el directorio "training" y siga estos pasos.

  • Descargue el archivo "lesion_annotations.zip". Extraiga los archivos en el directorio especificado por la variable.trainTumorAnnotationDir

  • Abra el directorio "normal". Descargue las imágenes en el directorio especificado por la variable.trainNormalDataDir

  • Abra el directorio "tumor". Descargue las imágenes en el directorio especificado por la variable.trainTumorDataDir

Especifique el número de imágenes de entrenamiento. Tenga en cuenta que una de las imágenes de entrenamiento del tejido normal, 'normal_144.tif', tiene metadatos que el objeto no puede leer.bigimage En este ejemplo se utilizan los 158 archivos de entrenamiento restantes.

numNormalFiles = 158; numTumorFiles = 111; 

Visualizar datos de entrenamiento

Para obtener una mejor comprensión de los datos de entrenamiento, muestre una imagen de entrenamiento. Dado que no es posible cargar toda la imagen en la memoria con la mejor resolución, no puede utilizar funciones tradicionales de visualización de imágenes como .imshow Para mostrar y procesar los datos de imagen, utilice un objeto.bigimage

Cree un objeto a partir de una imagen de entrenamiento de tumores.bigimage

tumorFileName = fullfile(trainTumorDataDir,'tumor_001.tif'); tumorImage = bigimage(tumorFileName);

Inspeccione las dimensiones de la en cada nivel de resolución.bigimage El nivel 1 tiene la mayoría de los píxeles y es el nivel de resolución más fino. El nivel 10 tiene el menor número de píxeles y es el nivel de resolución más grueso. La relación de aspecto no es coherente, lo que indica que los niveles no abarcan todos la misma zona mundial.

levelSizeInfo = table((1:length(tumorImage.LevelSizes))', ...     tumorImage.LevelSizes(:,1), ...     tumorImage.LevelSizes(:,2), ...     tumorImage.LevelSizes(:,1)./tumorImage.LevelSizes(:,2), ...     'VariableNames',["Resolution Level" "Image Width" "Image Height" "Aspect Ratio"])
levelSizeInfo=11×4 table
    Resolution Level    Image Width    Image Height    Aspect Ratio
    ________________    ___________    ____________    ____________

            1           2.2118e+05        97792           2.2618   
            2           1.1059e+05        49152             2.25   
            3                55296        24576             2.25   
            4                27648        12288             2.25   
            5                13824         6144             2.25   
            6                 7168         3072           2.3333   
            7                 3584         1536           2.3333   
            8                 2048         1024                2   
            9                 1024          512                2   
           10                  512          512                1   
           11                 1577         3629          0.43455   

Visualice el nivel de resolución en un nivel de resolución grueso mediante la función.bigimagebigimageshow Devuelve un identificador al objeto.bigimageshow Puede utilizar el asa para ajustar la visualización. La imagen contiene una gran cantidad de espacios en blanco vacíos. El tejido ocupa sólo una pequeña porción de la imagen.

h = bigimageshow(tumorImage,'ResolutionLevel',7);

Amplíe una parte de la imagen estableciendo las extensiones espaciales horizontales y verticales con respecto al nivel de resolución más fino. La imagen se ve borrosa porque este nivel de resolución es muy grueso.

xlim([29471,29763]); ylim([117450,118110]);

Para ver más detalles, cambie el nivel de resolución a un nivel más fino.

h.ResolutionLevel = 1;

Crear máscaras

Puede reducir la cantidad de cálculo procesando solo las regiones de interés (ROI). Utilice una máscara para definir los ROI. Una máscara es una imagen lógica en la que los píxeles representan el ROI.true

Para reducir aún más la cantidad de cálculo, cree máscaras en un nivel de resolución gruesa que se puedan procesar completamente en la memoria en lugar de bloque por bloque. Si la referencia espacial del nivel de resolución gruesa coincide con la referencia espacial de los niveles de resolución más finos, las ubicaciones en el nivel grueso corresponden a ubicaciones en niveles más finos. En este caso, puede utilizar la máscara gruesa para seleccionar los bloques que desea procesar en los niveles más finos. Para obtener más información, consulte y .Establecer referencia espacial para imágenes grandesProcesar imágenes grandes de manera eficiente usando la máscara

Especifique un nivel de resolución que se utilizará para crear la máscara. Este ejemplo utiliza el nivel de resolución 7, que es grueso y cabe en la memoria.

resolutionLevel = 7;

Crear máscaras para imágenes normales

En las imágenes normales, el ROI consiste en tejido sano. El color del tejido sano es distinto del color del fondo, así que utilice el umbral de color para segmentar la imagen y crear un ROI. El espacio de color L*a*b* proporciona la mejor separación de color para la segmentación. Convierta la imagen al espacio de color L*a*b* y, a continuación, umbral del canal a* para crear la máscara de tejido.

Puede utilizar la función auxiliar para crear máscaras mediante el umbral de color.createMaskForNormalTissue Esta función auxiliar se adjunta al ejemplo como un archivo auxiliar.

La función auxiliar realiza estas operaciones en cada imagen de entrenamiento del tejido normal:

  • Cree un objeto a partir del archivo . Archivo de imagen TIF.bigimage

  • Establezca la referencia espacial de todos los niveles de resolución a partir de los metadatos de la imagen.

  • Obtenga la imagen en el nivel de resolución gruesa.

  • Convierta la imagen gruesa al espacio de color L*a*b* y, a continuación, extraiga el canal a*.

  • Cree una imagen binaria mediante el umbral de la imagen mediante el método de Otsu, que minimiza la varianza intraclase entre los píxeles en blanco y negro.

  • Cree un objeto de resolución única a partir de la máscara y establezca la referencia espacial de la máscara para que coincida con la referencia espacial de la imagen de entrada.bigimage

  • Escriba la máscara en la memoria.bigimage Sólo el objeto está en la memoria.bigimage Los bloques de imagen individuales correspondientes a la imagen de máscara lógica se encuentran en un directorio temporal. Escribir en un directorio conserva la referencia espacial personalizada, lo que garantiza que las imágenes normales y sus imágenes de máscara correspondientes tengan la misma referencia espacial.

trainNormalMaskDir = fullfile(trainNormalDataDir,['normal_mask_level' num2str(resolutionLevel)]); createMaskForNormalTissue(trainNormalDataDir,trainNormalMaskDir,resolutionLevel)

Ahora que las imágenes normales y las máscaras están en el disco, cree objetos para administrar los datos mediante la función auxiliar .bigimagecreateBigImageAndMaskArrays Esta función crea una matriz de objetos a partir de las imágenes normales y una matriz correspondiente de objetos a partir de las imágenes de máscara normales.bigimagebigimage La función auxiliar se adjunta al ejemplo como un archivo auxiliar.

[bigNormalImages,bigNormalMasks] = createBigImageAndMaskArrays(trainNormalDataDir,trainNormalMaskDir);

Seleccione una imagen y una máscara normales de muestra. Confirme que las extensiones del mundo espacial de la máscara coinciden con las extensiones de la imagen en el nivel de resolución más fino. Las extensiones del mundo espacial se especifican mediante las propiedades y.XWorldLimitsYWorldLimits

idx = 2; bigNormalImages(idx).SpatialReferencing(1)
ans =    imref2d with properties:             XWorldLimits: [0 97792]            YWorldLimits: [0 221184]               ImageSize: [221184 97792]     PixelExtentInWorldX: 1     PixelExtentInWorldY: 1     ImageExtentInWorldX: 97792     ImageExtentInWorldY: 221184        XIntrinsicLimits: [0.5000 9.7793e+04]        YIntrinsicLimits: [0.5000 2.2118e+05]  
bigNormalMasks(idx).SpatialReferencing(1)
ans =    imref2d with properties:             XWorldLimits: [0 97792]            YWorldLimits: [0 221184]               ImageSize: [3456 1527]     PixelExtentInWorldX: 64.0419     PixelExtentInWorldY: 64     ImageExtentInWorldX: 97792     ImageExtentInWorldY: 221184        XIntrinsicLimits: [0.5000 1.5275e+03]        YIntrinsicLimits: [0.5000 3.4565e+03]  

Compruebe que la máscara contiene los ROI correctos y la referencia espacial. Muestre la imagen de ejemplo mediante la función.bigimageshow Obtenga los ejes que contienen la pantalla.

figure hBigNormal = bigimageshow(bigNormalImages(idx)); hNormalAxes = hBigNormal.Parent;

Cree un nuevo eje en la parte superior de la pantalla.bigimage En los nuevos ejes, muestre la imagen de máscara correspondiente con transparencia parcial. La máscara resalta las regiones que contienen tejido normal.

hMaskAxes = axes; hBigMask = bigimageshow(bigNormalMasks(idx),'Parent',hMaskAxes, ...     'Interpolation','nearest','AlphaData',0.5); hMaskAxes.Visible = 'off';

Vincule los ejes de la imagen con los ejes de la máscara. Al hacer zoom y desplazar, ambos ejes se actualizan de forma idéntica.

linkaxes([hNormalAxes,hMaskAxes]);

Amplíe una parte de la imagen estableciendo las extensiones espaciales horizontales y verticales. La máscara se superpone correctamente al tejido normal.

xlim([45000 80000]); ylim([130000 165000]);

Crear máscaras para imágenes de tumores

En las imágenes tumorales, el ROI consiste en tejido tumoral. El color del tejido tumoral es similar al color del tejido sano, por lo que no se pueden utilizar técnicas de segmentación de color. En su lugar, cree IRO utilizando las coordenadas de la verdad del suelo de los límites de la lesión que acompañan a las imágenes del tumor.

Puede utilizar la función auxiliar para crear una máscara mediante ROI.createMaskForTumorTissue Esta función auxiliar se adjunta al ejemplo como un archivo auxiliar.

La función auxiliar realiza estas operaciones en cada imagen de entrenamiento del tejido tumoral:

  • Cree un objeto a partir del archivo . Archivo de imagen TIF.bigimage

  • Establezca la referencia espacial a partir de los metadatos de la imagen.

  • Lea las anotaciones de lesión correspondientes en archivos XML y convierta las anotaciones en polígonos (objetos).Polygon

  • Para cada bloque de imagen, utilice los datos de polígono para crear una máscara para el bloque correspondiente. Las imágenes con regiones tumorales pueden contener algunas regiones normales dentro de ellas. Utilice las anotaciones de tejido normal para excluir esas regiones.

  • Cree un objeto de máscara lógica de salida a un nivel de resolución más grueso.bigimage Escriba la imagen de máscara bloque por bloque mediante la función.setBlock

  • Escriba el objeto mask en un directorio de memoria.bigimage Sólo el objeto está en la memoria.bigimage Los bloques de imagen individuales correspondientes a la imagen de máscara lógica se encuentran en un directorio temporal. Escribir en un directorio conserva la referencia espacial personalizada, lo que garantiza que las imágenes del tumor y sus imágenes de máscara correspondientes tengan la misma referencia espacial.

trainTumorMaskDir = fullfile(trainTumorDataDir,['tumor_mask_level' num2str(resolutionLevel)]); createMaskForTumorTissue(trainTumorDataDir,trainTumorAnnotationDir, ...     trainTumorMaskDir,resolutionLevel);

Ahora que tanto las imágenes tumorales como las máscaras están en el disco, cree objetos para administrar los datos mediante la función auxiliar .bigimagecreateBigImageAndMaskArrays Esta función crea una matriz de objetos a partir de las imágenes del tumor y una matriz correspondiente de objetos a partir de las imágenes de máscara tumoral.bigimagebigimage La función auxiliar se adjunta al ejemplo como un archivo auxiliar.

[bigTumorImages,bigTumorMasks] = createBigImageAndMaskArrays(trainTumorDataDir,trainTumorMaskDir);

Seleccione una imagen y una máscara de tumor de muestra. Confirme que las extensiones del mundo espacial de la máscara coinciden con las extensiones de la imagen en el nivel de resolución más fino. Las extensiones del mundo espacial se especifican mediante las propiedades y.XWorldLimitsYWorldLimits

idx = 5; bigTumorImages(idx).SpatialReferencing(1)
ans =    imref2d with properties:             XWorldLimits: [0 97792]            YWorldLimits: [0 219648]               ImageSize: [219648 97792]     PixelExtentInWorldX: 1     PixelExtentInWorldY: 1     ImageExtentInWorldX: 97792     ImageExtentInWorldY: 219648        XIntrinsicLimits: [0.5000 9.7793e+04]        YIntrinsicLimits: [0.5000 2.1965e+05]  
bigTumorMasks(idx).SpatialReferencing(1)
ans =    imref2d with properties:             XWorldLimits: [0 97792]            YWorldLimits: [0 219648]               ImageSize: [3432 1527]     PixelExtentInWorldX: 64.0419     PixelExtentInWorldY: 64     ImageExtentInWorldX: 97792     ImageExtentInWorldY: 219648        XIntrinsicLimits: [0.5000 1.5275e+03]        YIntrinsicLimits: [0.5000 3.4325e+03]  

Compruebe que la máscara contiene los ROI correctos y la referencia espacial. Muestre la imagen de ejemplo mediante la función.bigimageshow Obtenga los ejes que contienen la pantalla.

figure hBigTumor = bigimageshow(bigTumorImages(idx)); hTumorAxes = hBigTumor.Parent;

Cree un nuevo eje en la parte superior de la imagen grande mostrada. En los nuevos ejes, muestre la imagen de máscara correspondiente con transparencia parcial. La máscara resalta las regiones que contienen tejido normal.

hMaskAxes = axes; hBigMask = bigimageshow(bigTumorMasks(idx),'Parent',hMaskAxes, ...     'Interpolation','nearest','AlphaData',0.5); hMaskAxes.Visible = 'off';

Vincule los ejes de la imagen con los ejes de la máscara. Al hacer zoom y desplazar, ambos ejes se actualizan de forma idéntica.

linkaxes([hTumorAxes,hMaskAxes]);

Amplíe una parte de la imagen estableciendo las extensiones espaciales horizontales y verticales. La máscara se superpone correctamente al tejido tumoral.

xlim([45000 65000]); ylim([130000 150000]);

Crear Big Image Datastore para entrenamiento y validación

Para extraer parches de datos de entrenamiento de los objetos, utilice un archivo .bigimagebigimageDatastore Este almacén de datos lee parches de datos en un único nivel de resolución.bigimage Si especifica una máscara, el almacén de datos lee parches solo desde dentro de los bloques de ROI. Tenga en cuenta que cada bloque de máscara puede contener una mezcla de ROI y píxeles de fondo, lo que puede conducir a ambiguedad sobre si todo el bloque es ROI o fondo. Para quitar la ambiguedad, el almacén de datos tiene una propiedad.InclusionThreshold Esta propiedad le permite especificar la fracción mínima de píxeles dentro de un bloque de máscara necesario para que el bloque se considere ROI.true

Dos problemas principales con los parches de entrenamiento sin procesar pueden potencialmente sesgar la red. El primer problema es el desequilibrio de color resultante de la tinción de color no uniforme del tejido. El segundo problema es el desequilibrio de clase resultante de una cantidad desigual de tumor y tejido normal en los datos. Para corregir estos problemas, puede preprocesar y aumentar el almacén de datos.

Este ejemplo muestra cómo crear a para extraer el tumor y los parches normales para entrenar la red y cómo preprocesar y aumentar los almacenes de datos para evitar sesgar la red.bigimageDatastore

Crear almacén de datos para imágenes normales

Divida aleatoriamente las imágenes normales y las máscaras correspondientes en dos conjuntos. El conjunto de validación contiene dos imágenes seleccionadas aleatoriamente y las máscaras correspondientes. El conjunto de entrenamiento contiene las imágenes y máscaras restantes.

normalValidationIdx = randi(numNormalFiles,[1 2]); normalTrainIdx = setdiff(1:numNormalFiles,normalValidationIdx);

El tamaño del parche es pequeño en comparación con el tamaño de las entidades de la imagen. De forma predeterminada, se extraen parches sin superposición y sin huecos, lo que genera una gran cantidad de parches de entrenamiento.bigimageDatastore Puede reducir la cantidad de datos de entrenamiento mediante la propiedad para agregar un espacio entre los parches muestreados.BlockOffsets Especifique un desplazamiento de bloque que sea mayor que el tamaño del parche. Aumente el umbral de inclusión del valor predeterminado de modo que la red entrene en parches relativamente homogéneos.0.5

Los almacenes de datos y leer parches de imagen de imágenes normales en el nivel de resolución más fino para el entrenamiento y la validación, respectivamente.dsNormalDatadsNormalDataValidation

patchSize = [299,299,3];  normalStrideFactor = 10; dsNormalData = bigimageDatastore(bigNormalImages(normalTrainIdx),1, ...     'InclusionThreshold',0.75,'Mask',bigNormalMasks(normalTrainIdx), ...     'BlockSize',patchSize(1:2),'BlockOffsets',patchSize(1:2)*normalStrideFactor, ...     'IncompleteBlocks','exclude');  dsNormalDataValidation = bigimageDatastore(bigNormalImages(normalValidationIdx),1, ...     'InclusionThreshold',0.75,'Mask',bigNormalMasks(normalValidationIdx), ...     'BlockSize',patchSize(1:2),'IncompleteBlocks','exclude');

Previsualice los parches del almacén de datos que contienen imágenes de entrenamiento normales.

imagesToPreview = zeros([patchSize 10],'uint8'); for n = 1:10     im = read(dsNormalData);     imagesToPreview(:,:,:,n) = im{1}; end figure montage(imagesToPreview,'Size',[2 5],'BorderSize',10,'BackgroundColor','k'); title("Training Patches of Normal Tissue")

Crear almacén de datos para imágenes de tumores

Divida aleatoriamente las imágenes tumorales y las máscaras correspondientes en dos conjuntos. El conjunto de validación contiene dos imágenes y máscaras. El conjunto de entrenamiento contiene las imágenes y máscaras restantes.

tumorValidationIdx = randi(numTumorFiles,[1 2]); tumorTrainIdx = setdiff(1:numTumorFiles,tumorValidationIdx);

Crear una a partir de las imágenes y máscaras del tumor de entrenamiento.bigimageDatastore El tejido tumoral es más escaso que el tejido normal. Para aumentar la densidad de muestreo y generar más parches de entrenamiento, especifique un desplazamiento de bloque más pequeño. Tenga en cuenta que si desea entrenar con menos imágenes de entrenamiento, es posible que deba aumentar el tamaño del conjunto de entrenamiento disminuyendo aún más el desplazamiento del bloque.

Los almacenes de datos y leer parches de imágenes de imágenes tumorales al mejor nivel de resolución para el entrenamiento y la validación, respectivamente.dsTumorDatadsTumorDataValidation

tumorStrideFactor = 4; dsTumorData = bigimageDatastore(bigTumorImages(tumorTrainIdx),1, ...     'InclusionThreshold',0.75,'Mask',bigTumorMasks(tumorTrainIdx), ...     'BlockSize',patchSize(1:2),'BlockOffsets',patchSize(1:2)*tumorStrideFactor, ...     'IncompleteBlocks','exclude');  dsTumorDataValidation = bigimageDatastore(bigTumorImages(tumorValidationIdx),1, ...     'InclusionThreshold',0.75,'Mask',bigTumorMasks(tumorValidationIdx), ...     'BlockSize',patchSize(1:2),'IncompleteBlocks','exclude');

Previsualiza parches del almacén de datos que contienen imágenes de entrenamiento de tumores.

imagesToPreview = zeros([patchSize 10],'uint8'); for n = 1:10     im = read(dsTumorData);     imagesToPreview(:,:,:,n) = im{1}; end montage(imagesToPreview,'Size',[2 5],'BorderSize',10,'BackgroundColor','k'); title("Training Patches of Tumor Tissue")

Normalizar colores y aumentar los datos de entrenamiento

Las imágenes de entrenamiento tienen diferentes distribuciones de color porque el conjunto de datos proviene de diferentes fuentes y la tinción de color del tejido no da lugar a imágenes manchadas de forma idéntica. El preprocesamiento adicional es necesario para evitar sesgos de la red.

Para evitar la variabilidad del color, este ejemplo preprocesa los datos con técnicas de normalización de manchas estándar. Aplique la normalización y el aumento de manchas mediante la función con operaciones de preprocesamiento personalizadas especificadas por la función auxiliar .transformaugmentAndLabel Esta función se adjunta al ejemplo como un archivo auxiliar.

La función realiza estas operaciones:augmentAndLabel

  • Normalizar la tinción utilizando el normalizeStaining.m función [ ].4 La normalización de la mancha se realiza utilizando el método de Macenko, que separa los canales de color de H&E por desconvolución de color utilizando una matriz fija y luego recrea las imágenes normalizadas con mezcla corregida individual. La función devuelve la imagen normalizada, así como las imágenes de H&E.

  • Agregue fluctuación de color mediante la función.jitterColorHSV La fluctuación de color varía el color de cada parche al perturbar el contraste, el tono, la saturación y el brillo de la imagen. La fluctuación de color se realiza en el espacio de color HSV para evitar artefactos de color no deseados en la imagen RGB.

  • Aplicar combinaciones aleatorias de rotaciones de 90 grados y reflexión vertical y horizontal. Las transformaciones afines aleatorias hacen que la red sea independiente de la orientación de los datos de imagen de entrada.

  • Etiquete el parche como o .'normal''tumor'

Cada parche de imagen genera cinco parches aumentados y etiquetados: el parche normalizado por manchas, el parche normalizado con tinción con fluctuación de color, el parche normalizado por manchas con fluctuación de color y transformación afín aleatoria, la imagen de hematoxilina con afinación aleatoria transformación, y la imagen de eosin con transformación afín aleatoria.

Cree almacenes de datos que transformen las imágenes normales de entrenamiento y validación y etiquete los parches generados como .'normal'

dsLabelledNormalData = transform(dsNormalData, ...     @(x,info)augmentAndLabel(x,info,'normal'),'IncludeInfo',true); dsLabelledNormalDataValidation = transform(dsNormalDataValidation, ...     @(x,info)augmentAndLabel(x,info,'normal'),'IncludeInfo',true);

Cree almacenes de datos que transformen las imágenes de entrenamiento y validación del tumor y etiquete los parches generados como .'tumor'

dsLabelledTumorData = transform(dsTumorData, ...     @(x,info)augmentAndLabel(x,info,'tumor'),'IncludeInfo',true); dsLabelledTumorDataValidation = transform(dsTumorDataValidation, ...     @(x,info)augmentAndLabel(x,info,'tumor'),'IncludeInfo',true);

Equilibrar las clases de tumores y normales

La cantidad de tejido canceroso en las imágenes del tumor es muy pequeña en comparación con la cantidad de tejido normal. El preprocesamiento adicional es necesario para evitar entrenar a la red en datos desequilibrados de clase que contienen una gran cantidad de tejido normal y una cantidad muy pequeña de tejido tumoral.

Para evitar el desequilibrio de clases, en este ejemplo se define un almacén de datos personalizado denominado que selecciona aleatoriamente los parches de entrenamiento normales y tumorales de forma equilibrada.randomSamplingDatastore El script para definir este almacén de datos personalizado se adjunta al ejemplo como un archivo auxiliar. Para obtener más información, consulte .Develop Custom Datastore

Cree la costumbre a partir de los almacenes de datos de entrenamiento normales y tumorales.randomSamplingDatastore El almacén de datos de muestreo aleatorio proporciona minilotes de datos de entrenamiento a la red en cada iteración de la época.dsTrain

dsTrain = randomSamplingDatastore(dsLabelledTumorData,dsLabelledNormalData);

Para limitar el número de revisiones utilizadas durante la validación, en este ejemplo se define un almacén de datos personalizado denominado a que devuelve cinco revisiones de validación de cada clase.validationDatastore El script para definir este almacén de datos personalizado se adjunta al ejemplo como un archivo auxiliar.

Cree la costumbre a partir de los almacenes de datos de validación normales y tumorales.validationDatastore

numValidationPatchesPerClass = 5; dsValidation = validationDatastore(dsLabelledTumorDataValidation, ...     dsLabelledNormalDataValidation,numValidationPatchesPerClass);

Configurar capas de red Inception-v3

En este ejemplo se utiliza la red Inception-v3, una red neuronal convolucional que se entrena en más de un millón de imágenes de la base de datos ImageNet [ ].3 La red tiene 48 capas de profundidad y puede clasificar imágenes en 1.000 categorías de objetos, como teclado, ratón, lápiz y muchos animales. La red espera un tamaño de entrada de imagen de 299 por 299 con 3 canales.

La función devuelve una red Inception-v3 previamente entrenada.inceptionv3 (Deep Learning Toolbox) Inception-v3 requiere el paquete de soporte de Deep Learning Toolbox™ Model for Inception-v3 Network. Si este paquete de soporte no está instalado, la función proporciona un vínculo de descarga.

net = inceptionv3;

Reemplazar capas finales

Las capas convolucionales de la imagen de extracción de red se utilizan para clasificar la imagen de entrada. Estas dos capas contienen información sobre cómo combinar las entidades que la red extrae en probabilidades de clase, un valor de pérdida y etiquetas predichas. Para volver a entrenar una red previamente entrenada para clasificar nuevas imágenes, sustituya estas dos capas por nuevas capas adaptadas al nuevo conjunto de datos. Para obtener más información, consulte .Train Deep Learning Network to Classify New Images (Deep Learning Toolbox)

Extraiga el gráfico de capas de la red entrenada.

lgraph = layerGraph(net);

Busque los nombres de las dos capas que desea reemplazar mediante la función de soporte .findLayersToReplace Esta función se adjunta al ejemplo como un archivo auxiliar. En Inception-v3, estas dos capas se nombran y .'predictions''ClassificationLayer_predictions'

[learnableLayer,classLayer] = findLayersToReplace(lgraph)
learnableLayer =    FullyConnectedLayer with properties:            Name: 'predictions'     Hyperparameters      InputSize: 2048     OutputSize: 1000     Learnable Parameters        Weights: [1000×2048 single]           Bias: [1000×1 single]    Show all properties  
classLayer =    ClassificationOutputLayer with properties:              Name: 'ClassificationLayer_predictions'          Classes: [1000×1 categorical]       OutputSize: 1000     Hyperparameters     LossFunction: 'crossentropyex'  

El objetivo de este ejemplo es realizar la segmentación binaria entre dos clases, regiones tumorales y no tumorales. Cree una nueva capa totalmente conectada para dos clases. Reemplace la capa final original totalmente conectada con la nueva capa.

numClasses = 2; newLearnableLayer = fullyConnectedLayer(numClasses,'Name','predictions'); lgraph = replaceLayer(lgraph,learnableLayer.Name,newLearnableLayer);

Cree una nueva capa de clasificación para dos clases. Reemplace la capa de clasificación final original por la nueva capa.

newClassLayer = classificationLayer('Name','ClassificationLayer_predictions'); lgraph = replaceLayer(lgraph,classLayer.Name,newClassLayer);

Especificar opciones de entrenamiento

Entrene la red utilizando el solucionador de optimización.rmsprop Este solucionador ajusta automáticamente la velocidad de aprendizaje y el impulso para una convergencia más rápida. Especifique otros parámetros de hiperparámetro mediante la función.trainingOptions (Deep Learning Toolbox) Reduzca a un número pequeño porque la gran cantidad de datos de entrenamiento permite que la red alcance la convergencia antes.MaxEpochs Si tiene Parallel Computing Toolbox™ y los recursos de hardware disponibles para el entrenamiento multi-GPU o paralelo, acelere el entrenamiento especificando el argumento de par nombre-valor como o , respectivamente.ExecutionEnvironment'multi-gpu''parallel'

checkpointsDir = fullfile(trainingImageDir,'checkpoints'); if ~exist(checkpointsDir,'dir')     mkdir(checkpointsDir); end  options = trainingOptions('rmsprop', ...     'InitialLearnRate',1e-5, ...     'SquaredGradientDecayFactor',0.99, ...     'MaxEpochs',3, ...     'MiniBatchSize',32, ...     'Plots','training-progress', ...     'CheckpointPath',checkpointsDir, ...      'ValidationData',dsValidation, ...     'ExecutionEnvironment','auto', ...     'Shuffle','every-epoch');

Descargar y preprocesar datos de prueba

El conjunto de datos de prueba Camelyon16 consta de 130 WSI. Estas imágenes tienen tejido normal y tumoral. En este ejemplo se utilizan dos imágenes de prueba de los datos de prueba Camelyon16. El tamaño de cada archivo es de aproximadamente 2 GB.

Cree un directorio para almacenar los datos de prueba.

testingImageDir = fullfile(tempdir,'Camelyon16','testing'); if ~exist(testingImageDir,'dir')     mkdir(testingImageDir);     mkdir(fullfile(testingImageDir,'images'));     mkdir(fullfile(testingImageDir,'lesion_annotations')); end  testDataDir = fullfile(testingImageDir,'images'); testTumorAnnotationDir = fullfile(testingImageDir,'lesion_annotations');

Para descargar los datos de prueba, vaya a la Camelyon17 y haga clic en el primer enlace "CAMELYON16 data set". Abra el directorio "testing" y siga estos pasos.

  • Descargue el archivo "lesion_annotations.zip". Extraiga todos los archivos en el directorio especificado por la variable.testTumorAnnotationDir

  • Abra el directorio "imágenes". Descargue los dos primeros archivos, "test_001.tif" y "test_002.tif". Mueva los archivos al directorio especificado por la variable.testDataDir

Especifique el número de imágenes de prueba.

numTestFiles = 2;

Crear máscaras para imágenes de prueba

Las imágenes de prueba contienen una mezcla de imágenes normales y tumorales. Para reducir la cantidad de cálculo durante la clasificación, defina los ROI mediante la creación de máscaras.

Especifique un nivel de resolución que se utilizará para crear la máscara. Este ejemplo utiliza el nivel de resolución 7, que es grueso y cabe en la memoria.

resolutionLevel = 7;

Cree máscaras para las regiones que contienen tejido. Puede utilizar la función auxiliar para crear máscaras mediante el umbral de color.createMaskForNormalTissue Esta función auxiliar se adjunta al ejemplo como un archivo auxiliar. Para obtener más información acerca de esta función auxiliar, consulte .Crear máscaras para imágenes normales

testTissueMaskDir = fullfile(testDataDir,['test_tissuemask_level' num2str(resolutionLevel)]); createMaskForNormalTissue(testDataDir,testTissueMaskDir,resolutionLevel);

Crea máscaras para imágenes que contengan tejido tumoral. Omita las imágenes que no contengan tejido tumoral. Puede utilizar la función auxiliar para crear máscaras mediante objetos ROI.createMaskForTumorTissue Esta función auxiliar se adjunta al ejemplo como un archivo auxiliar. Para obtener más información acerca de esta función auxiliar, consulte .Crear máscaras para imágenes de tumores

testTumorMaskDir = fullfile(testDataDir,['test_tumormask_level' num2str(resolutionLevel)]); createMaskForTumorTissue(testDataDir,testTumorAnnotationDir,testTumorMaskDir,resolutionLevel);

Red de trenes

Después de configurar las opciones de entrenamiento y el origen de datos, entrene la red Inception-v3 mediante el trainNetwork Función. De forma predeterminada, en este ejemplo se descarga una versión previamente entrenada de la red Inception-v3 para este conjunto de datos mediante la función auxiliar .downloadTrainedCamelyonNet La función auxiliar se adjunta al ejemplo como un archivo auxiliar. La red previamente entrenada le permite ejecutar el ejemplo completo sin esperar a que se complete el entrenamiento.

Nota: El entrenamiento tarda 20 horas en un NVIDIA™ Titan X y puede tardar aún más dependiendo del hardware de tu GPU.

doTraining = false; if doTraining     trainedNet = trainNetwork(dsTrain,lgraph,options);     save(['trainedCamelyonNet-' datestr(now, 'dd-mmm-yyyy-HH-MM-SS') '.mat'],'trainedNet'); else     trainedCamelyonNet_url = 'https://www.mathworks.com/supportfiles/vision/data/trainedCamelyonNet.mat';     netDir = fullfile(tempdir,'Camelyon16');     downloadTrainedCamelyonNet(trainedCamelyonNet_url,netDir);     load(fullfile(netDir,'trainedCamelyonNet.mat')); end
Downloading pretrained Inception-v3 network for Cameylon16 data. This can take several minutes to download... Done. 

Clasificar datos de prueba y crear mapas de calor

Se recomienda encarecidamente una GPU para la clasificación de las imágenes de prueba (requiere Parallel Computing Toolbox™).

Cada imagen de prueba tiene dos máscaras, una que indica tejido normal y otra que indica tejido tumoral. Cree objetos para administrar los datos de prueba y las máscaras mediante la función auxiliar .bigimagecreateBigImageAndMaskArrays La función auxiliar se adjunta al ejemplo como un archivo auxiliar.

[bigTestImages,bigTestTissueMasks] = createBigImageAndMaskArrays(testDataDir,testTissueMaskDir); [~,bigTestTumorMasks] = createBigImageAndMaskArrays(testDataDir,testTumorMaskDir);

Utilice la red Inception-v3 entrenada para identificar parches tumorales en las imágenes de prueba, .bigTestImages Clasificar las imágenes de prueba bloque por bloque mediante la función con una canalización de procesamiento personalizada especificada por la función auxiliar .applycreateHeatMap Esta función auxiliar se adjunta al ejemplo como un archivo auxiliar. Para reducir la cantidad de cálculo necesario, especifique la máscara de tejido para que la función procese solo los parches que contienen tejido.bigTestTissueMaskapply Si tiene Parallel Computing Toolbox™ y una GPU, puede evaluar bloques en paralelo especificando el argumento de par nombre-valor como .'UseParallel'true

La función realiza estas operaciones en cada bloque de tejido:createHeatMap

  • Calcule la puntuación de probabilidad del tumor utilizando la función.predict (Deep Learning Toolbox)

  • Cree un parche de imagen de mapa de calor con valores de píxel iguales a la puntuación de probabilidad del tumor.

La función une el mapa de calor de cada bloque en un único mapa de calor para la imagen de prueba.apply El mapa de calor muestra dónde la red detecta las regiones que contienen tumores.

Para visualizar el mapa de calor, superponga el mapa de calor en la imagen original y establezca la propiedad transparency como máscara de tejido.'AlphaData' La superposición muestra qué tan bien se localiza el tumor en la imagen. Las regiones con una alta probabilidad de ser tumores se muestran con píxeles rojos. Las regiones con una baja probabilidad de ser tumores se muestran como píxeles azules.

patchSize = [299,299,3];  for idx = 1:numTestFiles     bigTestHeatMaps(idx) = apply(bigTestImages(idx),1,@(x)createHeatMap(x,trainedNet), ...         'Mask',bigTestTissueMasks(idx),'InclusionThreshold',0, ...         'BlockSize',patchSize(1:2),'UseParallel',false);          figure     hBigTest = bigimageshow(bigTestImages(idx));     hTestAxes = hBigTest.Parent;     hTestAxes.Visible = 'off';              hMaskAxes = axes;     hBigMask = bigimageshow(bigTestHeatMaps(idx),'Parent',hMaskAxes, ...         "Interpolation","nearest","AlphaData",bigTestTissueMasks(idx));     colormap(jet(255));     hMaskAxes.Visible = 'off';          linkaxes([hTestAxes,hMaskAxes]);     title(['Tumor Heatmap of Test Image ',num2str(idx)]) end

Referencias

[1] Ehteshami B. B., et al. "Evaluación Diagnóstica de Algoritmos de Aprendizaje Profundo para la Detección de Metástasis de Nodo Linfano en Mujeres con Cáncer de Mama." .Journal of the American Medical Association Vol. 318, No. 22, 2017, págs. 2199–2210.doi:10.1001/jama.2017.14585

[2] Szegedy, C., V. Vanhoucke, S. Ioffe, J. Shlens y Z. Wojna. "Repensar la arquitectura inicial para la visión por computadora." En , 2818-2826.Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Las Vegas, NV: IEEE, 2016.

[3] ImageNet. http://www.image-net.org.

[4] Macenko, M., et al. "Un método para normalizar diapositivas histológicas para el análisis cuantitativo." En , 1107-1110.2009 IEEE International Symposium on Biomedical Imaging: From Nano to Macro Boston, MA: IEEE, 2009.

[5] xml2struct .https://www.mathworks.com/matlabcentral/fileexchange/28518-xml2struct

Consulte también

| | | | (Deep Learning Toolbox) | (Deep Learning Toolbox)

Temas relacionados