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.

Segmentación del tumor cerebral 3-D mediante el aprendizaje profundo

Este ejemplo muestra cómo entrenar una red neuronal de U-net 3-D y realizar la segmentación semántica de los tumores cerebrales a partir de imágenes médicas 3-D.

El ejemplo muestra cómo entrenar una red de U-net 3-D y también proporciona una red preentrenada. Si elige entrenar la red, se recomienda encarecidamente el uso de una GPU NVIDIA™ compatible con CUDA con capacidad de cómputo 3,0 o superior (requiere Parallel Computing Toolbox™).

Si no desea descargar el conjunto de datos de entrenamiento completo o entrenar la red, puede cargar la U-net 3-D preentrenada y un conjunto de datos de prueba más pequeño. Vaya directamente a la sección en este ejemplo.Descargue la red Preentrenada y el conjunto de pruebas de muestra

Introducción

La segmentación semántica implica etiquetar cada píxel de una imagen, o vóxeles de un volumen 3-D, con una clase.

Este ejemplo ilustra el uso de métodos de aprendizaje profundo para segmentar semánticamente los tumores cerebrales en exploraciones por resonancia magnética (RM). También muestra cómo realizar la segmentación binaria, en la que cada vóxeles está etiquetado como tumor o fondo.

Un desafío de segmentación de imágenes médicas es el desequilibrio de clases en los datos que obstaculiza el entrenamiento cuando se usa la pérdida de entropía cruzada convencional. Este ejemplo resuelve el problema mediante una función de pérdida de dados de varias clases ponderada.3 El pesaje de las clases ayuda a contrarrestar la influencia de las regiones más grandes en la puntuación de dados, lo que facilita a la red aprender a segmentar regiones más pequeñas.

Este ejemplo realiza la segmentación del tumor cerebral utilizando una arquitectura de U-net 3D.1 U-net es una red rápida, eficiente y sencilla que se ha popularizado en el dominio de la segmentación semántica.

Descargar entrenamiento, validación y datos de prueba

Este ejemplo utiliza el conjunto de datos BraTS.2 El conjunto de datos BraTS contiene exploraciones por resonancia magnética de los tumores cerebrales, es decir, gliomas, que son las neoplasias cerebrales primarias más comunes. El tamaño del archivo de datos es ~ 7 GB. Si no desea descargar el conjunto de datos, vaya directamente a la sección de este ejemplo.Descargue la red Preentrenada y el conjunto de pruebas de muestra

Cree un directorio para almacenar el conjunto de datos BraTS.

imageDir = fullfile(tempdir,'BraTS','Task01_BrainTumor')
imageDir =  '/tmp/BraTS/Task01_BrainTumor' 
if ~exist(imageDir,'dir')     mkdir(imageDir); end

Para descargar los datos de BraTS, vaya al sitio web y haga clic en el enlace "descargar datos".Segmentación médica Decathalon Descargue el archivo ' Task01_BrainTumour. tar '. Descomprima el archivo TAR en el directorio especificado por la variable.imageDir

El conjunto de datos contiene volúmenes 750 4-D, cada uno representando una pila de imágenes 3D. Cada volumen 4-D tiene el tamaño 240-by-240-by-155-by-4, donde las primeras tres dimensiones corresponden a la altura, la anchura y la profundidad de una imagen volumétrica 3-D. La cuarta dimensión corresponde a diferentes modalidades de escaneo. Cada volumen de imagen tiene una etiqueta de píxel correspondiente. El conjunto de datos se divide en 484 volúmenes de entrenamiento y 286 volúmenes de prueba.

Preprocesar datos de entrenamiento y validación

Para entrenar la red de U-net 3-D más eficientemente, preprocese los datos de RMN utilizando la función auxiliar.preprocessBraTSdataset Esta función se adjunta al ejemplo como un archivo auxiliar.

La función auxiliar realiza estas operaciones:

  • Recorte los datos en una región que contenga principalmente el cerebro y el tumor. Recortar los datos reduce el tamaño de los datos conservando la parte más crítica de cada volumen de RMN y sus etiquetas correspondientes.

  • Normalice cada modalidad de cada volumen de forma independiente restando la media y dividiéndola por la desviación estándar de la región cerebral recortada.

  • Divida el conjunto de datos en conjuntos de pruebas, validación y entrenamiento.

El procesamiento previo de los datos puede tardar unos 30 minutos en completarse.

preprocessDataLoc = fullfile(tempdir,'BraTS','preprocessedDataset'); preprocessBraTSdataset(preprocessDataLoc,imageDir);

Define Random Patch Extraction Datastore for Training and Validation

Utilice un almacén de datos de extracción de parches al azar para alimentar a la red y validar el progreso del entrenamiento. Este almacén de datos extrae parches aleatorios de imágenes de verdad en tierra y datos de etiquetas de píxel correspondientes.

En primer lugar, almacene las imágenes de entrenamiento en un.imageDatastore Dado que el formato de archivo MAT es un formato de imagen no estándar, debe utilizar un lector de archivos MAT para habilitar la lectura de los datos de imagen. Puede utilizar el lector de archivo MAT auxiliar,.matRead Esta función se adjunta al ejemplo como un archivo auxiliar.

volReader = @(x) matRead(x); volLoc = fullfile(preprocessDataLoc,'imagesTr'); volds = imageDatastore(volLoc, ...     'FileExtensions','.mat','ReadFcn',volReader);

Cree una para almacenar las etiquetas.pixelLabelDatastore

labelReader = @(x) matRead(x); lblLoc = fullfile(preprocessDataLoc,'labelsTr'); classNames = ["background","tumor"]; pixelLabelID = [0 1]; pxds = pixelLabelDatastore(lblLoc,classNames,pixelLabelID, ...     'FileExtensions','.mat','ReadFcn',labelReader);

Previsualice un volumen de imagen y una etiqueta. Visualice el volumen etiquetado utilizando la función.labelvolshow Haga que el fondo sea totalmente transparente estableciendo la visibilidad de la etiqueta de fondo () en.10

volume = preview(volds); label = preview(pxds); h = labelvolshow(label,volume(:,:,:,1)); h.LabelVisibility(1) = 0;

Cree una a partir del almacén de datos de imagen y de etiquetas de píxel.randomPatchExtractionDatastore Especifique un tamaño de parche de 64-by-64-by-64 voxels. Especifique para extraer 16 parches colocados aleatoriamente de cada par de volúmenes y etiquetas durante el entrenamiento.'PatchesPerImage' Especifique un tamaño de mini lote de 8. Este paso es necesario para que los recursos de la GPU se puedan utilizar de forma eficaz para volúmenes arbitrariamente grandes sin que se le esté acabando la memoria.

patchSize = [64 64 64]; patchPerImage = 16; miniBatchSize = 8; patchds = randomPatchExtractionDatastore(volds,pxds,patchSize, ...     'PatchesPerImage',patchPerImage); patchds.MiniBatchSize = miniBatchSize;

Aumente los datos de entrenamiento mediante la función con operaciones de preprocesamiento personalizadas especificadas por la función auxiliar.transformaugment3dPatch La función rota aleatoriamente y refleja los datos de entrenamiento para hacer la formación más robusta.augment3dPatch Esta función se adjunta al ejemplo como un archivo auxiliar.

augpatchds = transform(patchds,@augment3dPatch);

Cree un que contenga los datos de validación.randomPatchExtrationDatastore Puede utilizar los datos de validación para evaluar si la red está aprendiendo continuamente, con un ajuste insuficiente o un sobreajuste a medida que avanza el tiempo.

volLocVal = fullfile(preprocessDataLoc,'imagesVal'); voldsVal = imageDatastore(volLocVal, ...     'FileExtensions','.mat','ReadFcn',volReader);  lblLocVal = fullfile(preprocessDataLoc,'labelsVal'); pxdsVal = pixelLabelDatastore(lblLocVal,classNames,pixelLabelID, ...     'FileExtensions','.mat','ReadFcn',labelReader);  patchdsVal = randomPatchExtractionDatastore(voldsVal,pxdsVal,patchSize, ...     'PatchesPerImage',patchPerImage); patchdsVal.MiniBatchSize = miniBatchSize;

Configurar capas de U-net 3-D

Este ejemplo utiliza una variación de la red de U-net 3-D.1 En U-net, la serie inicial de capas convolucionales se intercalan con capas de agrupación máxima, disminuyendo sucesivamente la resolución de la imagen de entrada. Estas capas van seguidas de una serie de capas convolucionales intercaladas con operadores de aumento de muestreo, aumentando sucesivamente la resolución de la imagen de entrada. El nombre U-net proviene del hecho de que la red se puede dibujar con una forma simétrica como la letra U. En este ejemplo se modifica el U-net para utilizar el relleno cero en las convoluciones, de modo que la entrada y la salida de las convoluciones tengan el mismo tamaño.

En este ejemplo se define la U-net 3-D utilizando capas de Deep Learning Toolbox™, incluyendo:

Este ejemplo también define una capa de pérdida de dados personalizada, nombrada, para resolver el problema del desequilibrio de clases en los datos.dicePixelClassidication3dLayer Esta capa se adjunta al ejemplo como un archivo auxiliar. Para obtener más información, consulte.Define Custom Pixel Classification Layer with Tversky Loss (Deep Learning Toolbox)

La primera capa,, opera en parches de imagen de tamaño 64-by-64-by-64 voxels.imageInput3dLayer

inputSize = [64 64 64 4]; inputLayer = image3dInputLayer(inputSize,'Normalization','none','Name','input');

La capa de entrada de imagen va seguida de la ruta de contratación de la U-net 3-D. La ruta de contratación consta de tres módulos de encoder. Cada codificador contiene dos capas de convolución con filtros de 3 por 3 por 3 que duplican el número de mapas de entidades, seguidos de una activación no lineal mediante la capa reLu. La primera convolución también es seguida por una capa de normalización de lotes. Cada codificador finaliza con una capa de agrupación máxima que reduce la resolución de la imagen en cada dimensión.

Dar nombres únicos a todas las capas. Las capas del codificador tienen nombres que empiezan por "en" seguido del índice del módulo del codificador. Por ejemplo, "en1" denota el primer módulo del codificador.

numFiltersEncoder = [     32 64;      64 128;      128 256];  layers = [inputLayer]; for module = 1:3     modtag = num2str(module);     encoderModule = [         convolution3dLayer(3,numFiltersEncoder(module,1), ...             'Padding','same','WeightsInitializer','normal', ...             'Name',['en',modtag,'_conv1']);         batchNormalizationLayer('Name',['en',modtag,'_bn']);         reluLayer('Name',['en',modtag,'_relu1']);         convolution3dLayer(3,numFiltersEncoder(module,2), ...             'Padding','same','WeightsInitializer','normal', ...             'Name',['en',modtag,'_conv2']);         reluLayer('Name',['en',modtag,'_relu2']);         maxPooling3dLayer(2,'Stride',2,'Padding','same', ...             'Name',['en',modtag,'_maxpool']);     ];          layers = [layers; encoderModule]; end

Cree la ruta de expansión de la U-net 3-D. El camino en expansión consta de cuatro módulos de descodificador. Todos los decodificadores contienen dos capas de convolución con filtros de 3 por 3 por 3 que reduce a la mitad el número de mapas de entidades, seguidos de una activación no lineal utilizando una capa reLu. Los primeros tres decodificadores concluyen con una capa de convolución transpuesta que upsamples la imagen por un factor de 2. El decodificador final incluye una capa de convolución que asigna el vector de característica de cada vóxeles a las clases.

Dar nombres únicos a todas las capas. Las capas del decodificador tienen nombres que empiezan por "de", seguidos por el índice del módulo del decodificador. Por ejemplo, "de4" denota el cuarto módulo de descodificador.

numFiltersDecoder = [     256 512;      256 256;      128 128;      64 64];  decoderModule4 = [     convolution3dLayer(3,numFiltersDecoder(1,1), ...         'Padding','same','WeightsInitializer','normal', ...         'Name','de4_conv1');     reluLayer('Name','de4_relu1');     convolution3dLayer(3,numFiltersDecoder(1,2), ...         'Padding','same','WeightsInitializer','normal', ...         'Name','de4_conv2');     reluLayer('Name','de4_relu2');     transposedConv3dLayer(2,numFiltersDecoder(1,2),'Stride',2, ...         'Name','de4_transconv'); ];  decoderModule3 = [     convolution3dLayer(3,numFiltersDecoder(2,1), ...         'Padding','same','WeightsInitializer','normal', ....         'Name','de3_conv1');            reluLayer('Name','de3_relu1');     convolution3dLayer(3,numFiltersDecoder(2,2), ...         'Padding','same','WeightsInitializer','normal', ...         'Name','de3_conv2');      reluLayer('Name','de3_relu2');     transposedConv3dLayer(2,numFiltersDecoder(2,2),'Stride',2, ...         'Name','de3_transconv'); ];  decoderModule2 = [     convolution3dLayer(3,numFiltersDecoder(3,1), ...         'Padding','same','WeightsInitializer','normal', ...         'Name','de2_conv1');     reluLayer('Name','de2_relu1');     convolution3dLayer(3,numFiltersDecoder(3,2), ...         'Padding','same','WeightsInitializer','normal', ...         'Name','de2_conv2');     reluLayer('Name','de2_relu2');     transposedConv3dLayer(2,numFiltersDecoder(3,2),'Stride',2, ...         'Name','de2_transconv'); ];

El decodificador final incluye una capa de convolución que mapea el vector de la entidad de cada vóxeles a cada una de las dos clases (tumor y fondo). La capa personalizada de clasificación de píxeles de dice pesa la función de pérdida para aumentar el impacto de las pequeñas regiones tumorales en la puntuación de dados.

numLabels = 2; decoderModuleFinal = [     convolution3dLayer(3,numFiltersDecoder(4,1), ...         'Padding','same','WeightsInitializer','normal', ...         'Name','de1_conv1');     reluLayer('Name','de1_relu1');     convolution3dLayer(3,numFiltersDecoder(4,2), ...         'Padding','same','WeightsInitializer','normal', ...         'Name','de1_conv2');     reluLayer('Name','de1_relu2');     convolution3dLayer(1,numLabels,'Name','convLast');     softmaxLayer('Name','softmax');     dicePixelClassification3dLayer('output'); ];

Concatenar los módulos de capa de entrada y Encoder con el cuarto módulo de descodificador. Agregue los otros módulos del decodificador al gráfico de capas como ramas separadas.

layers = [layers; decoderModule4]; lgraph = layerGraph(layers); lgraph = addLayers(lgraph,decoderModule3); lgraph = addLayers(lgraph,decoderModule2); lgraph = addLayers(lgraph,decoderModuleFinal);

Utilice capas de concatenación para conectar la segunda capa reLu de cada módulo del codificador con una capa de convolución transpuesta de igual tamaño a partir de un módulo de decodificador. Conecte la salida de cada capa de concatenación a la primera capa de convolución del módulo del decodificador.

concat1 = concatenationLayer(4,2,'Name','concat1'); lgraph = addLayers(lgraph,concat1); lgraph = connectLayers(lgraph,'en1_relu2','concat1/in1'); lgraph = connectLayers(lgraph,'de2_transconv','concat1/in2'); lgraph = connectLayers(lgraph,'concat1/out','de1_conv1');  concat2 = concatenationLayer(4,2,'Name','concat2'); lgraph = addLayers(lgraph,concat2); lgraph = connectLayers(lgraph,'en2_relu2','concat2/in1'); lgraph = connectLayers(lgraph,'de3_transconv','concat2/in2'); lgraph = connectLayers(lgraph,'concat2/out','de2_conv1');  concat3 = concatenationLayer(4,2,'Name','concat3'); lgraph = addLayers(lgraph,concat3); lgraph = connectLayers(lgraph,'en3_relu2','concat3/in1'); lgraph = connectLayers(lgraph,'de4_transconv','concat3/in2'); lgraph = connectLayers(lgraph,'concat3/out','de3_conv1'); 

Como alternativa, puede utilizar la función auxiliar para crear las capas de U-net 3-D.createUnet3d Esta función se adjunta al ejemplo como un archivo auxiliar.

lgraph = createUnet3d(inputSize);

Trace el gráfico de capas.

analyzeNetwork(lgraph)

Especifique opciones de formación

Entrena la red usando el solucionador de optimización "Adam". Especifique la configuración de hiperparámetros mediante la función.trainingOptions La tasa de aprendizaje inicial se establece en 5e-4 y disminuye gradualmente durante el lapso de entrenamiento.

options = trainingOptions('adam','MaxEpochs',100, ...     'InitialLearnRate',5e-4, ...     'LearnRateSchedule','piecewise', ...     'LearnRateDropPeriod',5, ...     'LearnRateDropFactor',0.95, ...     'ValidationData',patchdsVal, ...     'ValidationFrequency',400, ...     'Plots','training-progress', ...     'MiniBatchSize',miniBatchSize);

Descargue la red Preentrenada y el conjunto de pruebas de muestra

Opcionalmente, Descargue una versión preentrenada de U-net 3-D y cinco volúmenes de prueba de muestra y sus etiquetas correspondientes para el conjunto de datos BraTS. El modelo y los datos de muestra preentrenados le permiten realizar la segmentación en los datos de prueba sin descargar el conjunto de datos completo ni esperar a que la red se capacite.

trained3DUnet_url = 'https://www.mathworks.com/supportfiles/vision/data/brainTumor3DUNet.mat'; sampleData_url = 'https://www.mathworks.com/supportfiles/vision/data/sampleBraTSTestSet.tar.gz';  imageDir = fullfile(tempdir,'BraTS'); if ~exist(imageDir,'dir')     mkdir(imageDir); end downloadTrained3DUnetSampleData(trained3DUnet_url,sampleData_url,imageDir);

Entrena la red

Después de configurar las opciones de entrenamiento y la fuente de datos, entrene la red de U-net 3-D utilizando la función.trainNetwork Para entrenar la red, establezca el parámetro en el siguiente código.doTrainingtrue Una GPU NVIDIA™ compatible con CUDA con capacidad de cómputo 3,0 o superior es muy recomendable para el entrenamiento.

Si mantiene el parámetro en el siguiente código como, el ejemplo devuelve una red de U-net 3-D preentrenada.doTrainingfalse

Note: Training takes about 60 hours on an NVIDIA™ Titan X and can take even longer depending on your GPU hardware.

doTraining = false; if doTraining     [net,info] = trainNetwork(augpatchds,lgraph,options); else     load(fullfile(imageDir,'trained3DUNet','brainTumor3DUNet.mat')); end

Ahora puede utilizar el U-net para segmentar semánticamente los tumores cerebrales.

Realizar la segmentación de datos de prueba

Seleccione el origen de los datos de prueba que contienen volúmenes de verdad y etiquetas de terreno para las pruebas. Si mantiene el parámetro en el código siguiente como, a continuación, el ejemplo utiliza cinco volúmenes para la prueba.useFullTestSetfalse Si establece el parámetro en, a continuación, el ejemplo utiliza 55 imágenes de prueba seleccionadas del conjunto de datos completo.useFullTestSettrue

useFullTestSet = false; if useFullTestSet     volLocTest = fullfile(preprocessDataLoc,'imagesTest');     lblLocTest = fullfile(preprocessDataLoc,'labelsTest'); else     volLocTest = fullfile(imageDir,'sampleBraTSTestSet','imagesTest');     lblLocTest = fullfile(imageDir,'sampleBraTSTestSet','labelsTest');     classNames = ["background","tumor"];     pixelLabelID = [0 1]; end

Recorte la parte central de las imágenes y etiquetas para dimensionar 128-by-128-by-128 voxels utilizando la función auxiliar.centerCropMatReader Esta función se adjunta al ejemplo como un archivo auxiliar. La variable almacena las imágenes de prueba de verdad de tierra.voldsTest La variable almacena las etiquetas de la verdad del terreno.pxdsTest

windowSize = [128 128 128]; volReader = @(x) centerCropMatReader(x,windowSize); labelReader = @(x) centerCropMatReader(x,windowSize); voldsTest = imageDatastore(volLocTest, ...     'FileExtensions','.mat','ReadFcn',volReader); pxdsTest = pixelLabelDatastore(lblLocTest,classNames,pixelLabelID, ...     'FileExtensions','.mat','ReadFcn',labelReader);

Para cada imagen de prueba, agregue los volúmenes de imagen de la verdad y las etiquetas a las matrices de celdas. Utilice la red entrenada con la función para predecir las etiquetas de cada volumen de prueba.semanticseg

Después de realizar la segmentación, postprocesar las etiquetas pronosticadas etiquetando los vóxeles no cerebrales como, correspondientes al fondo.1 Utilice las imágenes de prueba para determinar qué vóxeles no pertenecen al cerebro. También puede limpiar las etiquetas previstas eliminando islas y llenando agujeros utilizando la función. no admite datos categoriales, por lo que se convierte los identificadores de etiqueta de píxel en antes del cálculo.medfilt3medfilt3uint8 A continuación, vuelva a convertir las etiquetas filtradas al tipo de datos categórico, especificando los identificadores de etiqueta de píxel originales y los nombres de clase.

id=1; while hasdata(voldsTest)     disp(['Processing test volume ' num2str(id)])          groundTruthLabels{id} = read(pxdsTest);          vol{id} = read(voldsTest);     tempSeg = semanticseg(vol{id},net);      % Get the non-brain region mask from the test image.     volMask = vol{id}(:,:,:,1)==0;     % Set the non-brain region of the predicted label as background.     tempSeg(volMask) = classNames(1);     % Perform median filtering on the predicted label.     tempSeg = medfilt3(uint8(tempSeg)-1);     % Cast the filtered label to categorial.     tempSeg = categorical(tempSeg,pixelLabelID,classNames);     predictedLabels{id} = tempSeg;     id=id+1; end
Processing test volume 1 Processing test volume 2 Processing test volume 3 Processing test volume 4 Processing test volume 5 

Compare verdad terrestre contra predicción de red

Seleccione una de las imágenes de prueba para evaluar la precisión de la segmentación semántica. Extraiga la primera modalidad de los datos volumétricos 4-D y almacene este volumen 3-D en la variable.vol3d

volId = 2; vol3d = vol{volId}(:,:,:,1);

Visualice en un montaje el trozo central de la verdad del terreno y las etiquetas pronosticadas a lo largo de la dirección de profundidad.

zID = size(vol3d,3)/2; zSliceGT = labeloverlay(vol3d(:,:,zID),groundTruthLabels{volId}(:,:,zID)); zSlicePred = labeloverlay(vol3d(:,:,zID),predictedLabels{volId}(:,:,zID));  figure title('Labeled Ground Truth (Left) vs. Network Prediction (Right)') montage({zSliceGT;zSlicePred},'Size',[1 2],'BorderSize',5) 

Mostrar el volumen con la etiqueta de tierra-verdad usando la función.labelvolshow Haga que el fondo sea totalmente transparente estableciendo la visibilidad de la etiqueta de fondo () en.10 Debido a que el tumor está dentro del tejido cerebral, Haz que algunos de los vóxeles cerebrales sean transparentes, para que el tumor sea visible. Para hacer que algunos vóxeles cerebrales sean transparentes, especifique el umbral de volumen como un número en el intervalo [0,1]. Todas las intensidades de volumen normalizadas por debajo de este valor de umbral son totalmente transparentes. Este ejemplo establece el umbral de volumen como menor que 1 para que algunos píxeles cerebrales permanezcan visibles, para dar contexto a la ubicación espacial del tumor dentro del cerebro.

figure h1 = labelvolshow(groundTruthLabels{volId},vol3d); h1.LabelVisibility(1) = 0; h1.VolumeThreshold = 0.68;

Para el mismo volumen, visualice las etiquetas pronosticadas.

figure h2 = labelvolshow(predictedLabels{volId},vol3d); h2.LabelVisibility(1) = 0; h2.VolumeThreshold = 0.68;

Esta imagen muestra el resultado de mostrar segmentos secuencialmente en todo el volumen.

Cuantificar la precisión de segmentación

Mida la precisión de la segmentación utilizando la función.dice Esta función calcula el coeficente de similitud de dice entre las segmentaciones de la verdad pronosticadas y terrestres.

diceResult = zeros(length(voldsTest.Files),2);  for j = 1:length(vol)     diceResult(j,:) = dice(groundTruthLabels{j},predictedLabels{j}); end

Calcule la puntuación media de los dados en el conjunto de volúmenes de prueba.

meanDiceBackground = mean(diceResult(:,1)); disp(['Average Dice score of background across ',num2str(j), ...     ' test volumes = ',num2str(meanDiceBackground)])
Average Dice score of background across 5 test volumes = 0.99341 
meanDiceTumor = mean(diceResult(:,2)); disp(['Average Dice score of tumor across ',num2str(j), ...     ' test volumes = ',num2str(meanDiceTumor)])
Average Dice score of tumor across 5 test volumes = 0.85204 

La figura muestra una que visualiza estadísticas sobre las puntuaciones de dados en el conjunto de cinco volúmenes de prueba de muestra.boxplot Las líneas rojas de la gráfica muestran la mediana del valor de dados para las clases. Los límites superior e inferior del cuadro azul indican los percentiles 25º y 75 º, respectivamente. Los bigotes negros se extienden a los puntos de datos más extremos que no se consideran valores atípicos.

Si tiene estadísticas y machine learning Toolbox™, puede utilizar la función para visualizar estadísticas sobre las puntuaciones de dados en todos los volúmenes de prueba.boxplot Para crear un, establezca el parámetro en el siguiente código.boxplotcreateBoxplottrue

createBoxplot = false; if createBoxplot     figure     boxplot(diceResult)     title('Test Set Dice Accuracy')     xticklabels(classNames)     ylabel('Dice Coefficient') end

Resumen

Este ejemplo muestra cómo crear y entrenar una red de U-net 3-D para realizar la segmentación del tumor cerebral 3-D utilizando el conjunto de datos BraTS. Los pasos para entrenar la red incluyen:

  • Descargue y preprocese los datos de entrenamiento.

  • Defina un que alimente los datos de entrenamiento a la red.randomPatchExtractionDatastore

  • Defina las capas de la red de U-net 3-D.

  • Especifique las opciones de formación.

  • Entrenar la red utilizando la función.trainNetwork

Después de entrenar la red 3-D U-net o cargar una red de U-net 3-D preentrenada, el ejemplo realiza la segmentación semántica de un conjunto de datos de prueba. El ejemplo evalúa la segmentación pronosticada por una comparación visual con la segmentación de la verdad del terreno y midiendo el coeficiente de similitud de los dados entre la segmentación de la verdad pronosticada y terrestre.

Referencias

[1] Çiçek, Ö., A. Abdulkadir, s. s. Lienkamp, T. Brox y O. Ronneberger. "3D U-net: Aprendizaje de segmentación volumétrica densa a partir de anotación dispersa. " En.Proceedings of the International Conference on Medical Image Computing and Computer-Assisted Intervention Atenas, Grecia, 2016 de octubre, págs. 424-432.

[2] Isensee, F., P. Kickingereder, W. Wick, M. Bendszus, y k. h. Maier-Hein. "Segmentación de tumores cerebrales y predicción de supervivencia Radiómica: Contribución al desafío BRATS 2017. " En.Proceedings of BrainLes: International MICCAI Brainlesion Workshop Ciudad de Quebec, Canadá, 2017 de septiembre, págs. 287-297.

[3] Sudre, c. h., W. Li, T. Vercauteren, S. Ourselin, y m. j. Cardoso. "Superposición de dados generalizados como una función de pérdida de aprendizaje profundo para segmentaciones altamente desequilibradas." .Deep Learning in Medical Image Analysis and Multimodal Learning for Clinical Decision Support: Third International Workshop Ciudad de Quebec, Canadá, 2017 de septiembre, págs. 240-248.

Consulte también

| | | | | |

Ejemplos relacionados

Más acerca de