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 semántica de imágenes multiespectrales mediante el aprendizaje profundo

Este ejemplo muestra cómo entrenar una red neuronal Convolucional de U-net para realizar la segmentación semántica de una imagen multiespectral con siete canales: tres canales de color, tres canales de infrarrojos cercanos y una máscara.

El ejemplo muestra cómo entrenar una red U-net y también proporciona una red U-net preentrenada. Si opta por entrenar la red U-net, 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™).

Introducción

La segmentación semántica implica etiquetar cada píxel de una imagen con una clase. Una aplicación de la segmentación semántica es el seguimiento de la deforestación, que es el cambio en la cubierta forestal a lo largo del tiempo. Las agencias medioambientales rastrean la deforestación para evaluar y cuantificar la salud ambiental y ecológica de una región.

La segmentación semántica basada en el aprendizaje profundo puede producir una medición precisa de la cubierta vegetal a partir de fotografías aéreas de alta resolución. Un desafío es diferenciar las clases con características visuales similares, como tratar de clasificar un píxel verde como hierba, arbustos o árboles. Para aumentar la precisión de la clasificación, algunos conjuntos de datos contienen imágenes multiespectrales que proporcionan información adicional sobre cada píxel. Por ejemplo, el conjunto de datos de Hamlin Beach State Park complementa las imágenes en color con canales de infrarrojo cercano que proporcionan una separación más clara de las clases.

En este ejemplo se muestra cómo utilizar técnicas de segmentación semántica basadas en el aprendizaje profundo para calcular el porcentaje de cobertura de vegetación en una región a partir de un conjunto de imágenes multiespectrales.

Descargar datos

Este ejemplo utiliza un conjunto de datos multiespectral de alta resolución para entrenar la red [1]. El conjunto de imágenes fue capturado usando un Dron sobre el parque estatal Hamlin Beach, NY. Los datos contienen formación etiquetada, validación y conjuntos de pruebas, con 18 etiquetas de clase de objeto.

Descargue la versión del archivo MAT del conjunto de datos. Puede utilizar la función auxiliar, para descargar los datos.downloadHamlinBeachMSIData El tamaño del archivo de datos es ~ 3,0 GB.

imageDir = tempdir; url = 'http://www.cis.rit.edu/~rmk6217/rit18_data.mat'; downloadHamlinBeachMSIData(url,imageDir);

Además, Descargue una versión preentrenada de U-net para este conjunto de datos. El modelo preentrenado le permite ejecutar el ejemplo completo sin tener que esperar a que finalice el entrenamiento.

trainedUnet_url = 'https://www.mathworks.com/supportfiles/vision/data/multispectralUnet.mat'; downloadTrainedUnet(trainedUnet_url,imageDir);

Inspeccione los datos de entrenamiento

Cargue el conjunto de datos en el espacio de trabajo de MATLAB®.

load(fullfile(imageDir,'rit18_data','rit18_data.mat'));

Examine la estructura de los datos.

whos train_data val_data test_data
  Name            Size                         Bytes  Class     Attributes    test_data       7x12446x7654            1333663576  uint16                 train_data      7x9393x5642              741934284  uint16                 val_data        7x8833x6918              855493716  uint16               

Los datos de imágenes multiespectrales se organizan como-por--por-arrays.numChannelswidthheight Sin embargo, en MATLAB, las imágenes multicanal se organizan como-por-por-arrays.widthheightnumChannels Para cambiar la forma de los datos de modo que los canales estén en la tercera dimensión, utilice la función auxiliar,.switchChannelsToThirdPlane

train_data = switchChannelsToThirdPlane(train_data); val_data   = switchChannelsToThirdPlane(val_data); test_data  = switchChannelsToThirdPlane(test_data);

Confirme que los datos tienen la estructura correcta.

whos train_data val_data test_data
  Name                Size                     Bytes  Class     Attributes    test_data       12446x7654x7            1333663576  uint16                 train_data       9393x5642x7             741934284  uint16                 val_data         8833x6918x7             855493716  uint16               

Los canales de color RGB son los canales de imagen 4º, 5º y 6º. Muestra el componente de color de las imágenes de entrenamiento, validación y prueba como un montaje. Para hacer que las imágenes parezcan más brillantes en la pantalla, ecualice sus histogramas utilizando la función.histeq

figure montage(...     {histeq(train_data(:,:,4:6)), ...     histeq(val_data(:,:,4:6)), ...     histeq(test_data(:,:,4:6))}, ...     'BorderSize',10,'BackgroundColor','white') title('RGB Component of Training Image (Left), Validation Image (Center), and Test Image (Right)')

Visualice los tres primeros canales ecualizados por histograma de los datos de entrenamiento como un montaje. Estos canales corresponden a las bandas de infrarrojo cercano y resaltan los diferentes componentes de la imagen en función de sus firmas de calor. Por ejemplo, los árboles cerca del centro de la imagen del 2º canal muestran más detalles que los árboles en los otros dos canales.

figure montage(...     {histeq(train_data(:,:,1)), ...     histeq(train_data(:,:,2)), ...     histeq(train_data(:,:,3))}, ...     'BorderSize',10,'BackgroundColor','white') title('IR Channels 1 (Left), 2, (Center), and 3 (Right) of Training Image')

El canal 7 es una máscara que indica la región de segmentación válida. Muestre la máscara para las imágenes de entrenamiento, validación y prueba.

figure montage(...     {train_data(:,:,7), ...     val_data(:,:,7), ...     test_data(:,:,7)}, ...     'BorderSize',10,'BackgroundColor','white') title('Mask of Training Image (Left), Validation Image (Center), and Test Image (Right)')

Las imágenes etiquetadas contienen los datos de la verdad del terreno para la segmentación, con cada píxel asignado a una de las 18 clases. Obtenga una lista de las clases con sus identificadores correspondientes.

disp(classes)
0. Other Class/Image Border       1. Road Markings                  2. Tree                           3. Building                       4. Vehicle (Car, Truck, or Bus)   5. Person                         6. Lifeguard Chair                7. Picnic Table                   8. Black Wood Panel               9. White Wood Panel               10. Orange Landing Pad            11. Water Buoy                    12. Rocks                         13. Other Vegetation              14. Grass                         15. Sand                          16. Water (Lake)                  17. Water (Pond)                  18. Asphalt (Parking Lot/Walkway) 

Cree un vector de nombres de clase.

classNames = [ "RoadMarkings","Tree","Building","Vehicle","Person", ...                "LifeguardChair","PicnicTable","BlackWoodPanel",...                "WhiteWoodPanel","OrangeLandingPad","Buoy","Rocks",...                "LowLevelVegetation","Grass_Lawn","Sand_Beach",...                "Water_Lake","Water_Pond","Asphalt"]; 

Superponer las etiquetas en la imagen de entrenamiento RGB ecualizada por histograma. Agregue un Colorbar a la imagen.

cmap = jet(numel(classNames)); B = labeloverlay(histeq(train_data(:,:,4:6)),train_labels,'Transparency',0.8,'Colormap',cmap);  figure title('Training Labels') imshow(B)
Warning: Image is too big to fit on screen; displaying at 13% 
N = numel(classNames); ticks = 1/(N*2):1/N:1; colorbar('TickLabels',cellstr(classNames),'Ticks',ticks,'TickLength',0,'TickLabelInterpreter','none'); colormap(cmap)

Guarde los datos de entrenamiento como un. MAT y las etiquetas de entrenamiento como. Archivo PNG.

save('train_data.mat','train_data'); imwrite(train_labels,'train_labels.png');

Define Mini-Batch Datastore for Training

Un almacén de datos mini-batch se utiliza para alimentar los data de entrenamiento a la red. En este ejemplo se define una implementación personalizada de un almacén de datos de minilotes, llamado, como una forma cómoda de generar parches de imagen aumentada y etiquetas para entrenar la red de segmentación semántica.PixelLabelImagePatchDatastore

Empiece almacenando las imágenes de entrenamiento en un.'train_data.mat'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 archivos MAT auxiliar, que extrae los primeros seis canales de los datos de entrenamiento y omite el último canal que contiene la máscara.matReader

imds = imageDatastore('train_data.mat','FileExtensions','.mat','ReadFcn',@matReader);

Cree una para almacenar las revisiones de etiquetas que contienen las 18 regiones etiquetadas.pixelLabelDatastore

pixelLabelIds = 1:18; pxds = pixelLabelDatastore('train_labels.png',classNames,pixelLabelIds);

Cree un randomPatchExtractionDatastore desde el almacén de datos Image y el almacén de datos de etiquetas de píxel. El randomPatchExtractionDatastore extrae pares de parches de la imagen de entrenamiento y las etiquetas. También aumenta los datos de entrenamiento para aumentar el tamaño del conjunto de datos de entrenamiento y para hacer la formación más robusta. Para imitar los datos del paisaje aéreo recogidos por un dron, aumenta los pares de parches agregando rotación aleatoria, reflexión y escalado.PixelLabelImagePatchDatastore

Cada mini-lote contiene 16 parches de tamaño 256-por-256 píxeles. 1000 mini-lotes se extraen en cada iteración de la época. Todos los parches se extraen de posiciones aleatorias en la imagen.

ds = randomPatchExtractionDatastore(imds,pxds,[256,256],'PatchesPerImage',16000)    
ds =    randomPatchExtractionDatastore with properties:           PatchesPerImage: 16000                PatchSize: [256 256]         DataAugmentation: 'none'            MiniBatchSize: 128          NumObservations: 16000     DispatchInBackground: 0  

Para entender lo que se pasa a la red durante el entrenamiento, llame a Preview en el randomPatchExtractionDatastore.

sampleBatch = preview(ds)
sampleBatch=8×2 table
        InputImage        ResponsePixelLabelImage
    __________________    _______________________

    [256×256×6 uint16]     [256×256 categorical] 
    [256×256×6 uint16]     [256×256 categorical] 
    [256×256×6 uint16]     [256×256 categorical] 
    [256×256×6 uint16]     [256×256 categorical] 
    [256×256×6 uint16]     [256×256 categorical] 
    [256×256×6 uint16]     [256×256 categorical] 
    [256×256×6 uint16]     [256×256 categorical] 
    [256×256×6 uint16]     [256×256 categorical] 

Cree capas de red de U-net

Este ejemplo utiliza una variación de la red U-net. 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 son seguidas por una serie de capas convolucionales intercaladas con operadores de aumento de muestreo, aumentando sucesivamente la resolución de la imagen de entrada [2]. 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. Utilice la función auxiliar, para crear un U-net con algunos hiperparámetros preseleccionados.createUnet

inputTileSize = [256,256,6]; lgraph = createUnet(inputTileSize); disp(lgraph.Layers)
  58x1 Layer array with layers:       1   'ImageInputLayer'                        Image Input                  256x256x6 images with 'zerocenter' normalization      2   'Encoder-Section-1-Conv-1'               Convolution                  64 3x3x6 convolutions with stride [1  1] and padding [1  1  1  1]      3   'Encoder-Section-1-ReLU-1'               ReLU                         ReLU      4   'Encoder-Section-1-Conv-2'               Convolution                  64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]      5   'Encoder-Section-1-ReLU-2'               ReLU                         ReLU      6   'Encoder-Section-1-MaxPool'              Max Pooling                  2x2 max pooling with stride [2  2] and padding [0  0  0  0]      7   'Encoder-Section-2-Conv-1'               Convolution                  128 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]      8   'Encoder-Section-2-ReLU-1'               ReLU                         ReLU      9   'Encoder-Section-2-Conv-2'               Convolution                  128 3x3x128 convolutions with stride [1  1] and padding [1  1  1  1]     10   'Encoder-Section-2-ReLU-2'               ReLU                         ReLU     11   'Encoder-Section-2-MaxPool'              Max Pooling                  2x2 max pooling with stride [2  2] and padding [0  0  0  0]     12   'Encoder-Section-3-Conv-1'               Convolution                  256 3x3x128 convolutions with stride [1  1] and padding [1  1  1  1]     13   'Encoder-Section-3-ReLU-1'               ReLU                         ReLU     14   'Encoder-Section-3-Conv-2'               Convolution                  256 3x3x256 convolutions with stride [1  1] and padding [1  1  1  1]     15   'Encoder-Section-3-ReLU-2'               ReLU                         ReLU     16   'Encoder-Section-3-MaxPool'              Max Pooling                  2x2 max pooling with stride [2  2] and padding [0  0  0  0]     17   'Encoder-Section-4-Conv-1'               Convolution                  512 3x3x256 convolutions with stride [1  1] and padding [1  1  1  1]     18   'Encoder-Section-4-ReLU-1'               ReLU                         ReLU     19   'Encoder-Section-4-Conv-2'               Convolution                  512 3x3x512 convolutions with stride [1  1] and padding [1  1  1  1]     20   'Encoder-Section-4-ReLU-2'               ReLU                         ReLU     21   'Encoder-Section-4-DropOut'              Dropout                      50% dropout     22   'Encoder-Section-4-MaxPool'              Max Pooling                  2x2 max pooling with stride [2  2] and padding [0  0  0  0]     23   'Mid-Conv-1'                             Convolution                  1024 3x3x512 convolutions with stride [1  1] and padding [1  1  1  1]     24   'Mid-ReLU-1'                             ReLU                         ReLU     25   'Mid-Conv-2'                             Convolution                  1024 3x3x1024 convolutions with stride [1  1] and padding [1  1  1  1]     26   'Mid-ReLU-2'                             ReLU                         ReLU     27   'Mid-DropOut'                            Dropout                      50% dropout     28   'Decoder-Section-1-UpConv'               Transposed Convolution       512 2x2x1024 transposed convolutions with stride [2  2] and output cropping [0  0  0  0]     29   'Decoder-Section-1-UpReLU'               ReLU                         ReLU     30   'Decoder-Section-1-DepthConcatenation'   Depth concatenation          Depth concatenation of 2 inputs     31   'Decoder-Section-1-Conv-1'               Convolution                  512 3x3x1024 convolutions with stride [1  1] and padding [1  1  1  1]     32   'Decoder-Section-1-ReLU-1'               ReLU                         ReLU     33   'Decoder-Section-1-Conv-2'               Convolution                  512 3x3x512 convolutions with stride [1  1] and padding [1  1  1  1]     34   'Decoder-Section-1-ReLU-2'               ReLU                         ReLU     35   'Decoder-Section-2-UpConv'               Transposed Convolution       256 2x2x512 transposed convolutions with stride [2  2] and output cropping [0  0  0  0]     36   'Decoder-Section-2-UpReLU'               ReLU                         ReLU     37   'Decoder-Section-2-DepthConcatenation'   Depth concatenation          Depth concatenation of 2 inputs     38   'Decoder-Section-2-Conv-1'               Convolution                  256 3x3x512 convolutions with stride [1  1] and padding [1  1  1  1]     39   'Decoder-Section-2-ReLU-1'               ReLU                         ReLU     40   'Decoder-Section-2-Conv-2'               Convolution                  256 3x3x256 convolutions with stride [1  1] and padding [1  1  1  1]     41   'Decoder-Section-2-ReLU-2'               ReLU                         ReLU     42   'Decoder-Section-3-UpConv'               Transposed Convolution       128 2x2x256 transposed convolutions with stride [2  2] and output cropping [0  0  0  0]     43   'Decoder-Section-3-UpReLU'               ReLU                         ReLU     44   'Decoder-Section-3-DepthConcatenation'   Depth concatenation          Depth concatenation of 2 inputs     45   'Decoder-Section-3-Conv-1'               Convolution                  128 3x3x256 convolutions with stride [1  1] and padding [1  1  1  1]     46   'Decoder-Section-3-ReLU-1'               ReLU                         ReLU     47   'Decoder-Section-3-Conv-2'               Convolution                  128 3x3x128 convolutions with stride [1  1] and padding [1  1  1  1]     48   'Decoder-Section-3-ReLU-2'               ReLU                         ReLU     49   'Decoder-Section-4-UpConv'               Transposed Convolution       64 2x2x128 transposed convolutions with stride [2  2] and output cropping [0  0  0  0]     50   'Decoder-Section-4-UpReLU'               ReLU                         ReLU     51   'Decoder-Section-4-DepthConcatenation'   Depth concatenation          Depth concatenation of 2 inputs     52   'Decoder-Section-4-Conv-1'               Convolution                  64 3x3x128 convolutions with stride [1  1] and padding [1  1  1  1]     53   'Decoder-Section-4-ReLU-1'               ReLU                         ReLU     54   'Decoder-Section-4-Conv-2'               Convolution                  64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     55   'Decoder-Section-4-ReLU-2'               ReLU                         ReLU     56   'Final-ConvolutionLayer'                 Convolution                  18 1x1x64 convolutions with stride [1  1] and padding [0  0  0  0]     57   'Softmax-Layer'                          Softmax                      softmax     58   'Segmentation-Layer'                     Pixel Classification Layer   Cross-entropy loss  

Seleccione opciones de formación

Entrena la red usando la optimización de descenso de gradiente estocástico con Momentum (SGDM). Especifique la configuración de hiperparámetros para SDGM mediante la función.trainingOptions

Entrenar una red profunda consume mucho tiempo. Acelere el entrenamiento especificando una alta tasa de aprendizaje. Sin embargo, esto puede hacer que los degradados de la red exploten o crezcan incontrolablemente, impidiendo que la red se capacite correctamente. Para mantener los degradados en un rango significativo, habilite el recorte de degradado estableciendo un valor de 0,05 y especifique que utilice la norma L2 de los degradados.'GradientThreshold''GradientThresholdMethod'

initialLearningRate = 0.05; maxEpochs = 150; minibatchSize = 16; l2reg = 0.0001;  options = trainingOptions('sgdm',...     'InitialLearnRate', initialLearningRate, ...     'Momentum',0.9,...     'L2Regularization',l2reg,...     'MaxEpochs',maxEpochs,...     'MiniBatchSize',minibatchSize,...     'VerboseFrequency',20,...     'LearnRateSchedule','piecewise',...         'Shuffle','every-epoch',...     'Plots','training-progress',...     'GradientThresholdMethod','l2norm',...     'GradientThreshold',0.05);

Entrena la red

Después de configurar las opciones de formación y el almacén de datos mini-batch, entrene la red U-net 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 código siguiente como, el ejemplo devuelve una red U-net preentrenada.doTrainingfalse

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

doTraining = false;  if doTraining          [net,info] = trainNetwork(ds,lgraph,options);  else      load(fullfile(imageDir,'trainedUnet','multispectralUnet.mat')); end

Ahora puede utilizar el U-net para segmentar semánticamente la imagen multiespectral.

Predecir resultados en datos de prueba

Para realizar el pase de reenvío en la red entrenada, utilice la función auxiliar, con el conjunto de datos de validación. realiza la segmentación en parches de imagen utilizando la función.segmentImagesegmentImagesemanticseg

predictPatchSize = [1024 1024]; segmentedImage = segmentImage(val_data,net,predictPatchSize);

Para extraer solo la parte válida de la segmentación, multiplique la imagen segmentada por el canal de máscara de los datos de validación.

segmentedImage = uint8(val_data(:,:,7)~=0) .* segmentedImage;  figure imshow(segmentedImage,[])
Warning: Image is too big to fit on screen; displaying at 13% 
title('Segmented Image')

La salida de la segmentación semántica es ruidosa. Realice el procesamiento de imágenes posteriores para eliminar el ruido y los píxeles perdidos. Utilice la función para eliminar el ruido de sal y pimienta de la segmentación.medfilt2 Visualice la imagen segmentada con el ruido eliminado.

segmentedImage = medfilt2(segmentedImage,[7,7]); imshow(segmentedImage,[]);
Warning: Image is too big to fit on screen; displaying at 13% 
title('Segmented Image  with Noise Removed')

Superponer la imagen segmentada en la imagen de validación RGB ecualizada por histograma.

B = labeloverlay(histeq(val_data(:,:,4:6)),segmentedImage,'Transparency',0.8,'Colormap',cmap);  figure imshow(B)
Warning: Image is too big to fit on screen; displaying at 13% 
title('Labeled Validation Image') colorbar('TickLabels',cellstr(classNames),'Ticks',ticks,'TickLength',0,'TickLabelInterpreter','none'); colormap(cmap)

Guarde las etiquetas de la imagen segmentada y la verdad del terreno como. Archivos PNG. Estos se usarán para calcular las métricas de precisión.

imwrite(segmentedImage,'results.png'); imwrite(val_labels,'gtruth.png');

Cuantificar la precisión de segmentación

Cree un para los resultados de segmentación y las etiquetas de la verdad del terreno.pixelLabelDatastore

pxdsResults = pixelLabelDatastore('results.png',classNames,pixelLabelIds); pxdsTruth = pixelLabelDatastore('gtruth.png',classNames,pixelLabelIds);

Mida la precisión global de la segmentación semántica mediante la función.evaluateSemanticSegmentation

ssm = evaluateSemanticSegmentation(pxdsResults,pxdsTruth,'Metrics','global-accuracy');
Evaluating semantic segmentation results ---------------------------------------- * Selected metrics: global accuracy. * Processing 1 images... [==================================================] 100% Elapsed time: 00:00:20 Estimated time remaining: 00:00:00 * Finalizing... Done. * Data set metrics:      GlobalAccuracy     ______________         0.90698     

La puntuación de precisión global indica que un poco más del 90% de los píxeles se clasifican correctamente.

Calcular la extensión de la cubierta vegetal

El objetivo final de este ejemplo es calcular la extensión de la cubierta vegetal en la imagen multiespectral.

Busca el número de píxeles etiquetados como vegetación. Los identificadores de etiqueta 2 ("árboles"), 13 ("Lowlevelvegetación") y 14 ("Grass_Lawn") son las clases de vegetación. También encontrará el número total de píxeles válidos sumando los píxeles en el ROI de la imagen de la máscara.

vegetationClassIds = uint8([2,13,14]); vegetationPixels = ismember(segmentedImage(:),vegetationClassIds); validPixels = (segmentedImage~=0);  numVegetationPixels = sum(vegetationPixels(:)); numValidPixels = sum(validPixels(:));

Calcule el porcentaje de la cubierta vegetal dividiendo el número de píxeles de vegetación por el número de píxeles válidos.

percentVegetationCover = (numVegetationPixels/numValidPixels)*100; fprintf('The percentage of vegetation cover is %3.2f%%.',percentVegetationCover);
The percentage of vegetation cover is 51.72%. 

Resumen

Este ejemplo muestra cómo crear y entrenar una red U-net para la segmentación semántica de una imagen multiespectral de siete canales. Estos fueron los pasos para entrenar la red:

  • Descargue y remodele los datos de entrenamiento.

  • Defina un almacén de datos de minilotes personalizado, denominado a desde el almacén de datos de imágenes y el almacén de datos de etiquetas de píxel.PixelLabelImagePatchDatastore Extrae los parches de la imagen comprimida de entrada y calcula los residuales de destino de los parches correspondientes en las imágenes prístinas.PixelLabelImagePatchDatastore Este datastore se usó para alimentar los datos de entrenamiento a la red.

  • Defina las capas de la red U-net.

  • Especifique las opciones de formación.

  • Entrenar la red utilizando la función.trainNetwork

Después de entrenar la red U-net o cargar una red U-net preentrenada, el ejemplo realiza la segmentación semántica de los datos de validación y mide la precisión de la segmentación.

Referencias

[1] Kemker, R., C. Salvaggio, y C. Kanan. "Conjunto de datos multiespectral de alta resolución para la segmentación semántica." CoRR, ABS/1703.01918. 2017.

[2] Ronneberger, O., P. Fischer, y T. Brox. "U-net: Redes convolucionales para la segmentación de imágenes biomédicas. " CoRR, ABS/1505.04597. 2015.

Consulte también

| | | | | | | |

Temas relacionados

Sitios web externos