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.

Aproximación del operador de procesamiento de imágenes mediante aprendizaje profundo

En este ejemplo se muestra cómo entrenar una red de agregación de contexto multiescala (CAN) que se utiliza para aproximar una operación de filtrado de imágenes.

En el ejemplo se muestra cómo entrenar una red CAN multiescala para aproximar un filtro bilateral y también proporciona una red previamente entrenada. Si decide entrenar la red, se recomienda utilizar una GPU NVIDIA™ compatible con CUDA con capacidad de computación 3.0 o superior. El uso de una GPU requiere el cuadro de herramientas de informática paralela™.

Introducción

La aproximación del operador encuentra formas alternativas de procesar imágenes de forma que el resultado se asemeje a la salida de una operación o canalización de procesamiento de imágenes convencional. El objetivo de la aproximación del operador es a menudo reducir el tiempo necesario para procesar una imagen.

Se han propuesto varias técnicas de aprendizaje clásico y profundo para realizar la aproximación del operador. Algunas técnicas clásicas mejoran la eficiencia de un solo algoritmo, pero no se pueden generalizar a otras operaciones. Otra técnica común se aproxima a una amplia gama de operaciones aplicando el operador a una copia de baja resolución de una imagen, pero la pérdida de contenido de alta frecuencia limita la precisión de la aproximación.

Las soluciones de aprendizaje profundo permiten la aproximación de operaciones más generales y complejas. Por ejemplo, la red de agregación de contexto multiescala (CAN) presentada por Q. Chen [ ] puede aproximar la asignación de tonos multiescala, la transferencia de estilo fotográfico, el deshazing no local y el dibujo a lápiz.1 Trenes CAN multiescala en imágenes de resolución completa para una mayor precisión en el procesamiento de detalles de alta frecuencia. Después de entrenar la red, la red puede pasar por alto la operación de procesamiento convencional y procesar imágenes directamente.

En este ejemplo se explora cómo entrenar un CAN multiescala para aproximar una operación bilateral de filtrado de imágenes, lo que reduce el ruido de la imagen y conserva la nitidez del borde. En el ejemplo se presenta el flujo de trabajo completo de formación e inferencia, que incluye el proceso de creación de un almacén de datos de entrenamiento, la selección de opciones de formación, el entrenamiento de la red y el uso de la red para procesar imágenes de prueba.

La red de aproximación del operador

El CAN multiescala está capacitado para minimizar la

<math display="inline">
<mrow>
<msub>
<mrow>
<mi mathvariant="italic">l</mi>
</mrow>
<mrow>
<mn>2</mn>
</mrow>
</msub>
</mrow>
</math>
pérdida entre la salida convencional de una operación de procesamiento de imágenes y la respuesta de red después de procesar la imagen de entrada mediante la agregación de contexto multiescala. La agregación de contexto multiescala busca información sobre cada píxel de toda la imagen, en lugar de limitar la búsqueda a un pequeño vecindario que rodea el píxel.

Para ayudar a la red a aprender las propiedades globales de la imagen, la arquitectura CAN multiescala tiene un campo receptivo grande. La primera y la última capas tienen el mismo tamaño porque el operador no debe cambiar el tamaño de la imagen. Las sucesivas capas intermedias se dilatan aumentando exponencialmente los factores de escala (de ahí la naturaleza "multiescala" de la CAN). La dilatación permite a la red buscar entidades separadas espacialmente en varias frecuencias espaciales, sin reducir la resolución de la imagen. Después de cada capa de convolución, la red utiliza la normalización adaptativa para equilibrar el impacto de la normalización por lotes y la asignación de identidad en el operador aproximado.

Descargar datos de entrenamiento y pruebas

Descargue el punto de referencia IAPR TC-12, que consta de 20.000 imágenes naturales [ ].2 El conjunto de datos incluye fotos de personas, animales, ciudades y mucho más. El tamaño del archivo de datos es de 1,8 GB. Si no desea descargar el conjunto de datos de entrenamiento necesario para entrenar la red, puede cargar el CAN previamente entrenado escribiendo en la línea de comandos.load('trainedOperatorLearning-Epoch-181.mat'); A continuación, vaya directamente a la sección de este ejemplo.Realizar aproximación de filtrado bilateral con CAN multiescala

imagesDir = tempdir; url_1 = 'http://www-i6.informatik.rwth-aachen.de/imageclef/resources/iaprtc12.tgz'; downloadIAPRTC12Data(url_1,imagesDir);

Este ejemplo entrena la red con un pequeño subconjunto de los datos de referencia IAPRTC-12.

trainImagesDir = fullfile(imagesDir,'iaprtc12','images','39'); exts = {'.jpg','.bmp','.png'}; pristineImages = imageDatastore(trainImagesDir,'FileExtensions',exts);

Enumere el número de imágenes de entrenamiento.

numel(pristineImages.Files)
ans = 916 

Preparar datos de capacitación

Para crear un conjunto de datos de entrenamiento, lea imágenes prístinas y escriba imágenes que se hayan filtrado bilateralmente. Las imágenes filtradas se almacenan en el disco en el directorio especificado por .preprocessDataDir

preprocessDataDir = [trainImagesDir filesep 'preprocessedDataset'];

Utilice la función auxiliar para preprocesar los datos de entrenamiento.bilateralFilterDataset Esta función se adjunta al ejemplo como un archivo auxiliar.

La función auxiliar realiza estas operaciones para cada imagen prístina en:inputImages

  • Calcule el grado de suavizado para el filtrado bilateral. El suavizado de la imagen filtrada reduce el ruido de la imagen.

  • Realice el filtrado bilateral utilizando .imbilatfilt

  • Guarde la imagen filtrada en el disco utilizando .imwrite

bilateralFilterDataset(pristineImages,preprocessDataDir);

Definir almacén de datos de extracción aleatoria de parches para el entrenamiento

Utilice un almacén de datos de extracción de parches aleatorio para enviar los datos de entrenamiento a la red. Este almacén de datos extrae los parches aleatorios correspondientes de dos almacenes de datos de imágenes que contienen las entradas de red y las respuestas de red deseadas.

En este ejemplo, las entradas de red son las imágenes prístinas en .pristineImages Las respuestas de red deseadas son las imágenes procesadas después del filtrado bilateral. Cree un almacén de datos de imágenes llamado a partir de la colección de archivos de imagen filtrados bilaterales.bilatFilteredImages

bilatFilteredImages = imageDatastore(preprocessDataDir,'FileExtensions',exts);

Cree a partir de los dos almacenes de datos de imagen.randomPatchExtractionDatastore Especifique un tamaño de parche de 256 por 256 píxeles. Especifique ' ' para extraer un parche colocado aleatoriamente de cada par de imágenes durante el entrenamiento.PatchesPerImage Especifique un tamaño de minilote de uno.

miniBatchSize = 1; patchSize = [256 256]; dsTrain = randomPatchExtractionDatastore(pristineImages,bilatFilteredImages,patchSize, ....     'PatchesPerImage',1); dsTrain.MiniBatchSize = miniBatchSize;

Proporciona mini-lotes de datos a la red en cada iteración de la época.randomPatchExtractionDatastore Realice una operación de lectura en el almacén de datos para explorar los datos.

inputBatch = read(dsTrain); disp(inputBatch)
       InputImage          ResponseImage       _________________    _________________      {256×256×3 uint8}    {256×256×3 uint8} 

Configurar capas CAN multiescala

En este ejemplo se define el CAN multiescala mediante capas de Deep Learning Toolbox™, que incluyen:

  • - Capa de entrada de imagenimageInputLayer (Deep Learning Toolbox)

  • - Capa de convolución 2D para redes neuronales convolucionalesconvolution2dLayer (Deep Learning Toolbox)

  • - Capa de normalización por lotesbatchNormalizationLayer (Deep Learning Toolbox)

  • - Capa de unidad lineal rectificada con fugasleakyReluLayer (Deep Learning Toolbox)

  • - Capa de salida de regresión para una red neuronalregressionLayer (Deep Learning Toolbox)

Se agregan dos capas de escala personalizadas para implementar una capa de normalización por lotes adaptable. Estas capas se adjuntan como archivos auxiliares a este ejemplo.

  • - Capa de escala que ajusta las fortalezas de la rama de normalización por lotesadaptiveNormalizationMu

  • - Capa de escala que ajusta las fortalezas de la rama de identidadadaptiveNormalizationLambda

La primera capa, , funciona en parches de imagen.imageInputLayer El tamaño del parche se basa en el campo receptivo de la red, que es la región de imagen espacial que afecta a la respuesta de la capa superior de la red. Idealmente, el campo receptivo de red es el mismo que el tamaño de la imagen para que pueda ver todas las entidades de alto nivel en la imagen. Para un filtro bilateral, el tamaño del parche de imagen de aproximación se fija a 256 por 256.

networkDepth = 10; numberOfFilters = 32; firstLayer = imageInputLayer([256 256 3],'Name','InputLayer','Normalization','none');

La capa de entrada de imagen va seguida de una capa de convolución 2D que contiene 32 filtros de tamaño 3 por 3. Cero las entradas de cada capa de convolución para que los mapas de entidades sigan siendo del mismo tamaño que la entrada después de cada convolución. Inicializar las ponderaciones en la matriz de identidad.

Wgts = zeros(3,3,3,numberOfFilters);  for ii = 1:3     Wgts(2,2,ii,ii) = 1; end convolutionLayer = convolution2dLayer(3,numberOfFilters,'Padding',1, ...     'Weights',Wgts,'Name','Conv1');

Cada capa de convolución va seguida de una capa de normalización por lotes y una capa de escala de normalización adaptable que ajusta las intensidades de la rama de normalización por lotes. Más adelante, este ejemplo creará la capa de escala de normalización adaptable correspondiente que ajusta la fuerza de la rama de identidad. Por ahora, siga la capa con una capa de adición.adaptiveNormalizationMu Por último, especifique una capa ReLU con fugas con un multiplicador escalar de entradas negativas.0.2

batchNorm = batchNormalizationLayer('Name','BN1'); adaptiveMu = adaptiveNormalizationMu(numberOfFilters,'Mu1'); addLayer = additionLayer(2,'Name','add1'); leakyrelLayer = leakyReluLayer(0.2,'Name','Leaky1');

Especifique las capas intermedias de la red siguiendo el mismo patrón. Las sucesivas capas de convolución tienen un factor de dilatación que se escala exponencialmente con la profundidad de red.

middleLayers = [convolutionLayer batchNorm adaptiveMu addLayer leakyrelLayer];      Wgts = zeros(3,3,numberOfFilters,numberOfFilters); for ii = 1:numberOfFilters     Wgts(2,2,ii,ii) = 1; end      for layerNumber = 2:networkDepth-2     dilationFactor = 2^(layerNumber-1);     padding = dilationFactor;     conv2dLayer = convolution2dLayer(3,numberOfFilters, ...         'Padding',padding,'DilationFactor',dilationFactor, ...         'Weights',Wgts,'Name',['Conv' num2str(layerNumber)]);     batchNorm = batchNormalizationLayer('Name',['BN' num2str(layerNumber)]);     adaptiveMu = adaptiveNormalizationMu(numberOfFilters,['Mu' num2str(layerNumber)]);     addLayer = additionLayer(2,'Name',['add' num2str(layerNumber)]);     leakyrelLayer = leakyReluLayer(0.2, 'Name', ['Leaky' num2str(layerNumber)]);     middleLayers = [middleLayers conv2dLayer batchNorm adaptiveMu addLayer leakyrelLayer];     end

No aplique un factor de dilatación a la penúltima capa de convolución.

conv2dLayer = convolution2dLayer(3,numberOfFilters, ...     'Padding',1,'Weights',Wgts,'Name','Conv9');  batchNorm = batchNormalizationLayer('Name','AN9'); adaptiveMu = adaptiveNormalizationMu(numberOfFilters,'Mu9'); addLayer = additionLayer(2,'Name','add9'); leakyrelLayer = leakyReluLayer(0.2,'Name','Leaky9'); middleLayers = [middleLayers conv2dLayer batchNorm adaptiveMu addLayer leakyrelLayer];

La última capa de convolución tiene un único filtro de tamaño 1 por 1 por 32 por 3 que reconstruye la imagen.

Wgts = sqrt(2/(9*numberOfFilters))*randn(1,1,numberOfFilters,3); conv2dLayer = convolution2dLayer(1,3,'NumChannels',numberOfFilters, ...     'Weights',Wgts,'Name','Conv10');

La última capa es una capa de regresión en lugar de una capa ReLU con fugas. La capa de regresión calcula el error cuadrado medio entre la imagen filtrada bilateralmente y la predicción de red.

finalLayers = [conv2dLayer      regressionLayer('Name','FinalRegressionLayer') ];

Concatenar todas las capas.

layers = [firstLayer middleLayers finalLayers']; lgraph = layerGraph(layers);

Cree conexiones de omisión, que actúan como la rama de identidad para la ecuación de normalización adaptable. Conecte las conexiones de omisión a las capas de adición.

skipConv1 = adaptiveNormalizationLambda(numberOfFilters,'Lambda1'); skipConv2 = adaptiveNormalizationLambda(numberOfFilters,'Lambda2'); skipConv3 = adaptiveNormalizationLambda(numberOfFilters,'Lambda3'); skipConv4 = adaptiveNormalizationLambda(numberOfFilters,'Lambda4'); skipConv5 = adaptiveNormalizationLambda(numberOfFilters,'Lambda5'); skipConv6 = adaptiveNormalizationLambda(numberOfFilters,'Lambda6'); skipConv7 = adaptiveNormalizationLambda(numberOfFilters,'Lambda7'); skipConv8 = adaptiveNormalizationLambda(numberOfFilters,'Lambda8'); skipConv9 = adaptiveNormalizationLambda(numberOfFilters,'Lambda9');  lgraph = addLayers(lgraph,skipConv1); lgraph = connectLayers(lgraph,'Conv1','Lambda1'); lgraph = connectLayers(lgraph,'Lambda1','add1/in2');  lgraph = addLayers(lgraph,skipConv2); lgraph = connectLayers(lgraph,'Conv2','Lambda2'); lgraph = connectLayers(lgraph,'Lambda2','add2/in2');  lgraph = addLayers(lgraph,skipConv3); lgraph = connectLayers(lgraph,'Conv3','Lambda3'); lgraph = connectLayers(lgraph,'Lambda3','add3/in2');  lgraph = addLayers(lgraph,skipConv4); lgraph = connectLayers(lgraph,'Conv4','Lambda4'); lgraph = connectLayers(lgraph,'Lambda4','add4/in2');  lgraph = addLayers(lgraph,skipConv5); lgraph = connectLayers(lgraph,'Conv5','Lambda5'); lgraph = connectLayers(lgraph,'Lambda5','add5/in2');  lgraph = addLayers(lgraph,skipConv6); lgraph = connectLayers(lgraph,'Conv6','Lambda6'); lgraph = connectLayers(lgraph,'Lambda6','add6/in2');  lgraph = addLayers(lgraph,skipConv7); lgraph = connectLayers(lgraph,'Conv7','Lambda7'); lgraph = connectLayers(lgraph,'Lambda7','add7/in2');  lgraph = addLayers(lgraph,skipConv8); lgraph = connectLayers(lgraph,'Conv8','Lambda8'); lgraph = connectLayers(lgraph,'Lambda8','add8/in2');  lgraph = addLayers(lgraph,skipConv9); lgraph = connectLayers(lgraph,'Conv9','Lambda9'); lgraph = connectLayers(lgraph,'Lambda9','add9/in2');

Como alternativa, puede utilizar esta función auxiliar para crear las capas CAN multiescala.

layers = operatorApproximationLayers;

Trazar el gráfico de capas.

plot(lgraph)

Especificar opciones de entrenamiento

Entrene la red usando el optimizador Adam. Especifique la configuración de hiperparámetro mediante la función.trainingOptions (Deep Learning Toolbox) Utilice los valores predeterminados de for ' ' y para ' ' (deterioro del peso).0.9Momentum0.0001L2Regularization Especifique una tasa de aprendizaje constante de .0.0001 Entrena para 181 épocas.

maxEpochs = 181; initLearningRate = 0.0001; miniBatchSize = 1;  options = trainingOptions('adam', ...     'InitialLearnRate',initLearningRate, ...     'MaxEpochs',maxEpochs, ...     'MiniBatchSize',miniBatchSize, ...     'Plots','training-progress', ...     'Verbose',false);

Entrenar la red

Ahora que el origen de datos y las opciones de entrenamiento están configurados, entrene el CAN multiescala mediante el archivo .trainNetwork (Deep Learning Toolbox)function Para entrenar la red, establezca el parámetro en el código siguiente en .doTrainingtrue Una GPU NVIDIA™ compatible con CUDA con capacidad de computación 3.0 o superior es muy recomendable para el entrenamiento.

Si mantiene el parámetro en el código siguiente como , el ejemplo devuelve un CAN multiescala entrenado previamente que se ha entrenado para aproximar un filtro bilateral.doTrainingfalse

Nota: El entrenamiento suele tardar unas 15 horas NVIDIA™ Titan X y puede tomar aún más tiempo dependiendo de su hardware GPU.

doTraining = false; if doTraining     modelDateTime = datestr(now,'dd-mmm-yyyy-HH-MM-SS');     net = trainNetwork(dsTrain,layers,options);     save(['trainedOperatorLearning-' modelDateTime '-Epoch-' num2str(maxEpochs) '.mat'],'net'); else     load('trainedOperatorLearning-Epoch-181.mat'); end

Realizar aproximación de filtrado bilateral con CAN multiescala

Para procesar una imagen mediante una red CAN multiescala entrenada que se aproxime a un filtro bilateral, siga los pasos restantes de este ejemplo. El resto del ejemplo muestra cómo:

  • Cree una imagen de entrada de ejemplo ruidoso a partir de una imagen de referencia.

  • Realice el filtrado bilateral convencional de la imagen ruidoso utilizando la función.imbilatfilt

  • Realice una aproximación al filtrado bilateral en la imagen ruidoso utilizando la CAN.

  • Compare visualmente las imágenes desruidos de la aproximación del operador y el filtrado bilateral convencional.

  • Evalúe la calidad de las imágenes desruidos cuantificando la similitud de las imágenes con la imagen de referencia prístina.

Crear una imagen de muestra de noisy

Cree una imagen de muestra ruidoso que se utilizará para comparar los resultados de la aproximación del operador con el filtrado bilateral convencional. El conjunto de datos de prueba, , contiene 21 imágenes prístinas incluidas en Image Processing Toolbox™.testImages Cargue las imágenes en un archivo .imageDatastore

exts = {'.jpg','.png'}; fileNames = {'sherlock.jpg','car2.jpg','fabric.png','greens.jpg','hands1.jpg','kobi.png',...     'lighthouse.png','micromarket.jpg','office_4.jpg','onion.png','pears.png','yellowlily.jpg',...     'indiancorn.jpg','flamingos.jpg','sevilla.jpg','llama.jpg','parkavenue.jpg',...     'peacock.jpg','car1.jpg','strawberries.jpg','wagon.jpg'}; filePath = [fullfile(matlabroot,'toolbox','images','imdata') filesep]; filePathNames = strcat(filePath,fileNames); testImages = imageDatastore(filePathNames,'FileExtensions',exts);

Muestre las imágenes de prueba como un montaje.

montage(testImages)

Seleccione una de las imágenes que desea utilizar como imagen de referencia para el filtrado bilateral. Convierta la imagen al tipo de datos .uint8

indx = 3; % Index of image to read from the test image datastore Ireference = readimage(testImages,indx); Ireference = im2uint8(Ireference);

Opcionalmente, puede utilizar su propia imagen como imagen de referencia. Tenga en cuenta que el tamaño de la imagen de prueba debe ser de al menos 256 por 256. Si la imagen de prueba es menor que 256 por 256, aumente el tamaño de la imagen mediante la función.imresize La red también requiere una imagen de prueba RGB. Si la imagen de prueba es en escala de grises, convierta la imagen a RGB utilizando la función para concatenar tres copias de la imagen original a lo largo de la tercera dimensión.cat

Muestre la imagen de referencia.

imshow(Ireference) title('Pristine Reference Image')

Utilice la función para añadir ruido blanco gaussiano de media cero con una varianza de 0.00001 a la imagen de referencia.imnoise

Inoisy = imnoise(Ireference,'gaussian',0.00001); imshow(Inoisy) title('Noisy Image')

Filtrar imagen mediante filtrado bilateral

El filtrado bilateral convencional es una forma estándar de reducir el ruido de la imagen y preservar la nitidez de los bordes. Utilice la función para aplicar un filtro bilateral a la imagen ruidoso.imbilatfilt Especifique un grado de suavizado igual a la varianza de los valores de píxel.

degreeOfSmoothing = var(double(Inoisy(:))); Ibilat = imbilatfilt(Inoisy,degreeOfSmoothing); imshow(Ibilat) title('Denoised Image Obtained Using Bilateral Filtering')

Procesar imagen utilizando una red entrenada

Pase la imagen de entrada normalizada a través de la red entrenada y observe la capa final (una capa de regresión).activations (Deep Learning Toolbox) La salida de la red es la imagen desruido deseada.

Iapprox = activations(net,Inoisy,'FinalRegressionLayer');

Cuadro de herramientas de procesamiento de imágenes™ requiere que las imágenes de punto flotante tengan valores de píxel en el intervalo [0, 1]. Utilice la función para escalar los valores de píxel a este rango y, a continuación, convierta la imagen a .rescaleuint8

Iapprox = rescale(Iapprox); Iapprox = im2uint8(Iapprox); imshow(Iapprox) title('Denoised Image Obtained Using Multiscale CAN')

Comparación visual y cuantitativa

Para obtener una mejor comprensión visual de las imágenes desruidos, examine una pequeña región dentro de cada imagen. Especifique una región de interés (ROI) utilizando vector en el formato [ ].roixywidthheight Los elementos definen la coordenada x e y de la esquina superior izquierda y la anchura y altura del ROI.

roi = [300 30 50 50];

Recorte las imágenes a este ROI y muestre el resultado como un montaje.

montage({imcrop(Ireference,roi),imcrop(Inoisy,roi), ...     imcrop(Ibilat,roi),imcrop(Iapprox,roi)}, ...     'Size',[1 4]); title('Reference Image | Noisy Image | Bilateral-Filtered Image | CAN Prediction');

El CAN elimina más ruido que el filtrado bilateral convencional. Ambas técnicas conservan la nitidez del borde.

Utilice métricas de calidad de imagen para comparar cuantitativamente la imagen de entrada ruidoso, la imagen filtrada bilateralmente y la imagen aproximada del operador. La imagen de referencia es la imagen de referencia original, antes de añadir ruido.Ireference

Mida la relación señal-ruido pico (PSNR) de cada imagen contra la imagen de referencia. Los valores PSNR más grandes generalmente indican una mejor calidad de imagen. Consulte para obtener más información acerca de esta métrica.psnr

noisyPSNR = psnr(Inoisy,Ireference); bilatPSNR = psnr(Ibilat,Ireference); approxPSNR = psnr(Iapprox,Ireference); disp(['PSNR of: Noisy Image / Bilateral-Filtered Image / Operator Approximated Image = ', ...     num2str([noisyPSNR bilatPSNR approxPSNR])])
PSNR of: Noisy Image / Bilateral-Filtered Image / Operator Approximated Image = 20.2857      25.7978      26.2011 

Mida el índice de similitud estructural (SSIM) de cada imagen. SSIM evalúa el impacto visual de tres características de una imagen: luminancia, contraste y estructura, frente a una imagen de referencia. Cuanto más cerca esté el valor de SSIM de 1, mejor estará la imagen de prueba de acuerdo con la imagen de referencia. Consulte para obtener más información acerca de esta métrica.ssim

noisySSIM = ssim(Inoisy,Ireference); bilatSSIM = ssim(Ibilat,Ireference); approxSSIM = ssim(Iapprox,Ireference); disp(['SSIM of: Noisy Image / Bilateral-Filtered Image / Operator Approximated Image = ', ...     num2str([noisySSIM bilatSSIM approxSSIM])])
SSIM of: Noisy Image / Bilateral-Filtered Image / Operator Approximated Image = 0.76251     0.91576     0.92663 

Mida la calidad de imagen perceptiva utilizando el evaluador de calidad de imagen natural (NIQE). Las puntuaciones MÁS pequeñas de NIQE indican una mejor calidad perceptiva. Consulte para obtener más información acerca de esta métrica.niqe

noisyNIQE = niqe(Inoisy); bilatNIQE = niqe(Ibilat); approxNIQE = niqe(Iapprox); disp(['NIQE score of: Noisy Image / Bilateral-Filtered Image / Operator Approximated Image = ', ...     num2str([noisyNIQE bilatNIQE approxNIQE])])
NIQE score of: Noisy Image / Bilateral-Filtered Image / Operator Approximated Image = 12.1865      7.22606      6.18105 

En comparación con el filtrado bilateral convencional, la aproximación del operador produce mejores puntuaciones métricas.

Resumen

En este ejemplo se muestra cómo crear y entrenar un CAN multiescala para aproximar un filtro bilateral. Estos son los pasos para entrenar la red:

  • Descargue los datos de entrenamiento.

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

  • Defina las capas del CAN multiescala.

  • Especifique las opciones de entrenamiento.

  • Entrene la red utilizando la función.trainNetwork (Deep Learning Toolbox)

Después de entrenar el CAN multiescala o cargar una red previamente entrenada, el ejemplo se aproxima a una operación de filtrado bilateral en una imagen ruidoso. El ejemplo compara el resultado con un filtro bilateral convencional que no utiliza aprendizaje profundo. La aproximación del operador supera al filtrado bilateral con respecto tanto a la calidad de imagen perceptiva como a las mediciones cuantitativas de calidad.

Referencias

[1] Chen, Q. J. Xu y V. Koltun. "Procesamiento rápido de imágenes con redes totalmente convolucionales." En.Proceedings of the 2017 IEEE Conference on Computer Vision Venecia, Italia, octubre de 2017, págs. 2516-2525.

[2] Grubinger, M., P. Clough, H. M.ller y T. Deselaers. "El punto de referencia IAPR TC-12: Un nuevo recurso de evaluación para sistemas de información visual." .Proceedings of the OntoImage 2006 Language Resources For Content-Based Image Retrieval Génova, Italia. 5 de mayo de 2006, pág. 10.

Consulte también

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

Temas relacionados