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.

Superresolución de una sola imagen mediante el aprendizaje profundo

En este ejemplo se muestra cómo entrenar una red neuronal de superresolución muy profunda (VDSR) y, a continuación, utilizar una red VDSR para estimar una imagen de alta resolución a partir de una sola imagen de baja resolución.

El ejemplo muestra cómo entrenar una red VDSR y también proporciona una red VDSR preentrenada. Si opta por entrenar la red VDSR, se recomienda encarecidamente el uso de una GPU NVIDIA™ compatible con CUDA con capacidad de cómputo 3,0 o superior. El uso de una GPU requiere la caja de herramientas de computación paralela™.

Si no desea descargar el conjunto de datos de entrenamiento o entrenar la red, puede cargar la red de VDSR preentrenada escribiendo en la línea de comandos.load('trainedVDSR-Epoch-100-ScaleFactors-234.mat'); A continuación, vaya directamente a la sección de este ejemplo.Perform Single Image Super-Resolution Using VDSR Network

Introducción

La superresolución es el proceso de crear imágenes de alta resolución a partir de imágenes de baja resolución. En este ejemplo se considera la superresolución de una sola imagen (SISR), donde el objetivo es recuperar una imagen de alta resolución de una imagen de baja resolución. SISR es desafiante porque el contenido de imagen de alta frecuencia no puede recuperarse normalmente de la imagen de baja resolución. Sin información de alta frecuencia, la calidad de la imagen de alta resolución es limitada. Además, SISR es un problema mal planteado porque una imagen de baja resolución puede producir varias imágenes de alta resolución posibles.

Se han propuesto varias técnicas, incluyendo algoritmos de aprendizaje profundo, para realizar SISR. Este ejemplo explora un algoritmo de aprendizaje profundo para SISR, llamado superresolución muy profunda (VDSR) [1].

La red VDSR

VDSR es una arquitectura de red neuronal convolucional diseñada para realizar una superresolución de imagen única [1]. La red VDSR aprende el mapeo entre imágenes de baja y alta resolución. Esta asignación es posible porque las imágenes de baja resolución y alta resolución tienen un contenido de imagen similar y difieren principalmente en detalles de alta frecuencia.

VDSR emplea una estrategia de aprendizaje residual, lo que significa que la red aprende a estimar una imagen residual. En el contexto de la superresolución, una imagen residual es la diferencia entre una imagen de referencia de alta resolución y una imagen de baja resolución que se ha escalado mediante la interpolación bicúbica para que coincida con el tamaño de la imagen de referencia. Una imagen residual contiene información sobre los detalles de alta frecuencia de una imagen.

La red VDSR detecta la imagen residual de la luminancia de una imagen en color. El canal de luminancia de una imagen, representa el brillo de cada píxel a través de una combinación lineal de los valores de píxel rojo, verde y azul.Y Por el contrario, los dos canales de crominancia de una imagen y, son diferentes combinaciones lineales de los valores de píxel rojo, verde y azul que representan la información de diferencia de color.CbCr El VDSR se entrena utilizando sólo el canal de luminancia porque la percepción humana es más sensible a los cambios de brillo que a los cambios de color.

Si

<math display="inline">
<mrow>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">high</mi>
<mi mathvariant="normal">res</mi>
</mrow>
</msub>
</mrow>
</math>
es la luminancia de la imagen de alta resolución y
<math display="inline">
<mrow>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">lowres</mi>
</mrow>
</msub>
</mrow>
</math>
es la luminancia de una imagen de baja resolución que se ha escalado mediante la interpolación bicúbica, la entrada a la red VDSR se
<math display="inline">
<mrow>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">lowres</mi>
</mrow>
</msub>
</mrow>
</math>
y la red aprende a predecir
<math display="inline">
<mrow>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">residual</mi>
</mrow>
</msub>
<mtext></mtext>
<mo>=</mo>
<mtext></mtext>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">highres</mi>
</mrow>
</msub>
<mo>-</mo>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">lowres</mi>
</mrow>
</msub>
</mrow>
</math>
de los datos de entrenamiento.

Después de que la red de VDSR aprenda a estimar la imagen residual, puede reconstruir imágenes de alta resolución agregando la imagen residual estimada a la imagen de baja resolución, y luego convirtiendo la imagen de nuevo al espacio de color RGB.

Un factor de escala relaciona el tamaño de la imagen de referencia con el tamaño de la imagen de baja resolución. A medida que aumenta el factor de escala, SISR se vuelve más mal puesto porque la imagen de baja resolución pierde más información sobre el contenido de imagen de alta frecuencia. VDSR resuelve este problema mediante el uso de un gran campo receptivo. Este ejemplo entrena una red VDSR con múltiples factores de escala utilizando el aumento de escala. El aumento de escala mejora los resultados a mayores factores de escala porque la red puede aprovechar el contexto de la imagen a partir de factores de escala más pequeños. Además, la red VDSR puede generalizarse para aceptar imágenes con factores de interescala.

Descargar datos de entrenamiento y prueba

Descargue el benchmark IAPR TC-12, que consta de 20.000 imágenes fijas naturales [2]. El conjunto de datos incluye fotos de personas, animales, ciudades y más. Puede utilizar la función auxiliar, para descargar los datos.downloadIAPRTC12Data El tamaño del archivo de datos es ~ 1,8 GB.

imagesDir = tempdir; url = 'http://www-i6.informatik.rwth-aachen.de/imageclef/resources/iaprtc12.tgz'; downloadIAPRTC12Data(url,imagesDir);
Downloading IAPR TC-12 dataset... This will take several minutes to download and unzip... done. 

Este ejemplo capacitará a la red con un pequeño subconjunto de los datos de Benchmark de IAPR TC-12. Cargue los datos de entrenamiento de imageCLEF. Todas las imágenes son imágenes en color JPEG de 32 bits.

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

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

numel(trainImages.Files)
ans = 616 

Prepare los datos de entrenamiento

Para crear un conjunto de datos de entrenamiento, preprocese las imágenes mediante la función auxiliar.createVDSRTrainingSet Esta función se adjunta al ejemplo como un archivo auxiliar.

La función auxiliar preprocesa las imágenes convirtiendo las imágenes al espacio de color YCbCr, redimensionando el canal de luminancia (Y) por diferentes factores de escala mediante la interpolación bicúbica y el cálculo de la diferencia entre las imágenes prístinas y redimensionadas. Las imágenes de entrada procesadas se almacenan en el disco como archivos. MAT en el directorio.upsampledDirName Las imágenes residuales calculadas se almacenan en el disco como archivos. MAT en el directorio.residualDirName Los archivos. MAT se almacenan como tipo de datos para una mayor precisión al entrenar la red.double

scaleFactors = [2 3 4]; [upsampledDirName,residualDirName] = createVDSRTrainingSet(trainImages,scaleFactors);

Definir canalización de preprocesamiento para el conjunto de entrenamiento

Utilice un almacén de datos combinado para alimentar los datos de entrenamiento a la red. Este almacén de datos extrae los parches correspondientes aleatorios de dos almacenes de datos de imagen que contienen las entradas de red y las respuestas de red deseadas.

En este ejemplo, las entradas de red son imágenes de baja resolución que se han escalado con la interpolación bicúbica. Las respuestas de red deseadas son las imágenes residuales. Cree un almacén de datos de imagen llamado desde la colección de archivos de imagen de entrada.upsampledImages Cree un almacén de datos de imagen llamado desde la colección de archivos de imágenes residuales calculados.residualImages Ambos almacenes requieren una función auxiliar, para leer los datos de imagen de los archivos de imagen.matRead Esta función se adjunta al ejemplo como un archivo auxiliar.

upsampledImages = imageDatastore(upsampledDirName,'FileExtensions','.mat','ReadFcn',@matRead); residualImages = imageDatastore(residualDirName,'FileExtensions','.mat','ReadFcn',@matRead);

Utilice la función para crear un único almacén de datos que contenga pares asociados de imágenes y imágenes residuales incluidas en el muestreo.combine

dsTrain = combine(upsampledImages,residualImages);

Cree un que especifique los parámetros de aumento de datos.imageDataAugmenter Utilice el aumento de datos durante el entrenamiento para variar los datos de entrenamiento, lo que aumenta eficazmente la cantidad de datos de entrenamiento disponibles. Aquí, el aumentador especifica la rotación aleatoria en 90 grados y las reflexiones aleatorias en la dirección.x-

augmenter = imageDataAugmenter( ...     'RandRotation',@()randi([0,1],1)*90, ...     'RandXReflection',true);

Utilice la función para aplicar el aumento aleatorio definido en el conjunto de entrenamiento.transformimageDataAugmenter La función acepta matrices de celdas de imágenes asociadas y aumenta cada imagen de la misma manera, lo que es necesario en los problemas de regresión de imagen a imagen.augment

dsTrain = transform(dsTrain,@(imagePair) augment(augmenter,imagePair));

Como paso final en la canalización de preprocesamiento, realice una extracción de parches aleatoria utilizando la función.transform La extracción de parches es el proceso de extraer un gran conjunto de pequeños parches de imagen, o mosaicos, a partir de una sola imagen más grande. Este tipo de aumento de datos se utiliza con frecuencia en problemas de regresión de imagen a imagen, donde muchas arquitecturas de red se pueden entrenar en tamaños de imagen de entrada muy pequeños. Esto significa que se puede extraer un gran número de parches de cada imagen de tamaño completo en el conjunto de entrenamiento original, lo que aumenta en gran medida el tamaño del conjunto de entrenamiento.

Este ejemplo define las operaciones de extracción de parches en la función e, que se incluye al final de este ejemplo.xtractImagePatches

patchSize = [41 41]; patchesPerImage = 64; dsTrain = transform(dsTrain,@(imagePair) extractImagePatches(imagePair,patchesPerImage,patchSize));

El almacén de datos resultante, proporciona minilotes de información a la red en cada iteración de la época.dsTrain Realice una operación de vista previa en el almacén de datos para explorar la información.

inputBatch = preview(dsTrain); disp(inputBatch)
    [41×41 double]    [41×41 double]     [41×41 double]    [41×41 double]     [41×41 double]    [41×41 double]     [41×41 double]    [41×41 double]     [41×41 double]    [41×41 double]     [41×41 double]    [41×41 double]     [41×41 double]    [41×41 double]     [41×41 double]    [41×41 double] 

Configurar capas de VDSR

En este ejemplo se define la red VDSR utilizando 41 capas individuales de Deep Learning Toolbox™, incluyendo:

La primera capa, opera en parches de imagen.imageInputLayer El tamaño del parche se basa en el campo receptivo de red, que es la región de la imagen espacial que afecta a la respuesta de la capa superior de la red. Idealmente, el campo receptivo de la red es el mismo que el tamaño de la imagen de modo que pueda ver todas las características de alto nivel en la imagen. En este caso, para una red de profundidad, el campo receptivo es (2 + 1)-por-(2 + 1).DDD Dado que VDSR es una red de 20 capas, el campo receptivo y el tamaño del parche de imagen son 41-by-41. La capa de entrada de imagen acepta imágenes con un canal porque el VDSR se entrena utilizando únicamente el canal de luminancia.

networkDepth = 20; firstLayer = imageInputLayer([41 41 1],'Name','InputLayer','Normalization','none');

La capa de entrada de imagen va seguida de una capa convolucional 2-D que contiene 64 filtros de tamaño 3 por 3. El tamaño del mini lote determina el número de filtros. Cero-Pad las entradas a cada capa convolucional para que los mapas de entidades sigan siendo del mismo tamaño que la entrada después de cada convolución. El método de él [3] inicializa los pesos a valores aleatorios para que exista una asimetría en el aprendizaje de la neurona. Cada capa convolucional va seguida de una capa ReLU, que introduce la no linealidad en la red.

convolutionLayer = convolution2dLayer(3,64,'Padding',1, ...     'Name','Conv1'); convolutionLayer.Weights = sqrt(2/(9*64))*randn(3,3,1,64); convolutionLayer.Bias = zeros(1,1,64);

Especifique una capa ReLU.

relLayer = reluLayer('Name','ReLU1');

Las capas intermedias contienen 18 capas de unidades lineales rectificadas y convolucionales alternas. Cada capa convolucional contiene 64 filtros de tamaño 3-por-3-por-64, donde un filtro opera en una región espacial de 3 por 3 a través de 64 canales. El método de él [3] inicializa los pesos a valores aleatorios. Como antes, una capa ReLU sigue cada capa convolucional.

middleLayers = [convolutionLayer relLayer]; for layerNumber = 2:networkDepth-1     conv2dLayer = convolution2dLayer(3,64, ...         'Padding',[1 1], ...         'Name',['Conv' num2str(layerNumber)]);          % He initialization     conv2dLayer.Weights = sqrt(2/(9*64))*randn(3,3,64,64);     conv2dLayer.Bias = zeros(1,1,64);          relLayer = reluLayer('Name',['ReLU' num2str(layerNumber)]);     middleLayers = [middleLayers conv2dLayer relLayer];     end

La penúltima capa es una capa convolucional con un único filtro de tamaño 3x3x64 que reconstruye la imagen.

conv2dLayer = convolution2dLayer(3,1,...     'NumChannels',64,...     'Padding',[1 1],...     'Name',['Conv' num2str(networkDepth)]); conv2dLayer.Weights = sqrt(2/(9*64))*randn(3,3,64,1); conv2dLayer.Bias = zeros(1,1,1);

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

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

Concatenar todas las capas para formar la red VDSR.

layers = [firstLayer middleLayers finalLayers];

Como alternativa, puede utilizar esta función auxiliar para crear capas de VDSR.

layers = vdsrLayers();

Especifique 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 La tasa de aprendizaje se establece inicialmente en 0,1 y luego se disminuye en un factor de 10 cada 20 epochs. Tren para 100 epochs.

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,01 y especifique que utilice la norma L2 de los degradados.'GradientThreshold''GradientThresholdMethod'

maxEpochs = 100; epochIntervals = 1; initLearningRate = 0.1; learningRateFactor = 0.1; l2reg = 0.0001; miniBatchSize = 64; options = trainingOptions('sgdm', ...     'Momentum',0.9, ...     'InitialLearnRate',initLearningRate, ...     'LearnRateSchedule','piecewise', ...     'LearnRateDropPeriod',10, ...     'LearnRateDropFactor',learningRateFactor, ...     'L2Regularization',l2reg, ...     'MaxEpochs',maxEpochs ,...     'MiniBatchSize',miniBatchSize, ...     'GradientThresholdMethod','l2norm', ...     'Plots','training-progress', ...     'GradientThreshold',0.01);

Entrena la red

Después de configurar las opciones de formación y el almacén de datos de extracción de parches aleatorios, entrene la red VDSR 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, a continuación, el ejemplo devuelve una red VDSR preentrenada que se ha entrenado para superresolver imágenes para los factores de escala 2, 3 y 4.doTrainingfalse

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

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

Realice una superresolución de imagen única con la red VDSR

Para realizar una superresolución de imagen única (SISR) utilizando la red VDSR, siga los pasos restantes de este ejemplo. El resto del ejemplo muestra cómo:

  • Cree una imagen de baja resolución de muestra a partir de una imagen de referencia de alta resolución.

  • Realice SISR en la imagen de baja resolución utilizando la interpolación bicúbica, una solución de procesamiento de imágenes tradicional que no se basa en el aprendizaje profundo.

  • Realice SISR en la imagen de baja resolución utilizando la red neuronal VDSR.

  • Compare visualmente las imágenes de alta resolución reconstruidas mediante interpolación bicúbica y VDSR.

  • Evalúe la calidad de las imágenes superresueltas cuantificando la similitud de las imágenes con la imagen de referencia de alta resolución.

Cree una imagen de baja resolución de muestra

Cree una imagen de baja resolución que se utilizará para comparar los resultados de la superresolución mediante el aprendizaje profundo del resultado mediante técnicas tradicionales de procesamiento de imágenes, como la interpolación bicúbica. El conjunto de datos de prueba contiene 21 imágenes no distorsionadas que se envían en Image Processing Toolbox™.testImages Cargue las imágenes en un.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);

Visualice las imágenes de prueba como un montaje.

montage(testImages)

Seleccione una de las imágenes que se utilizarán como imagen de referencia para la superresolución. Opcionalmente, puede utilizar su propia imagen de alta resolución como imagen de referencia.

indx = 1; % Index of image to read from the test image datastore Ireference = readimage(testImages,indx); Ireference = im2double(Ireference); imshow(Ireference) title('High-Resolution Reference Image')

Cree una versión de baja resolución de la imagen de referencia de alta resolución mediante el uso de un factor de escalado de 0,25.imresize Los componentes de alta frecuencia de la imagen se pierden durante el escalado descendente.

scaleFactor = 0.25; Ilowres = imresize(Ireference,scaleFactor,'bicubic'); imshow(Ilowres) title('Low-Resolution Image')

Mejore la resolución de imagen mediante interpolación bicúbica

Una forma estándar de aumentar la resolución de la imagen sin aprendizaje profundo es utilizar la interpolación bicúbica. Reutilice la imagen de baja resolución utilizando la interpolación bicúbica para que la imagen de alta resolución resultante tenga el mismo tamaño que la imagen de referencia.

[nrows,ncols,np] = size(Ireference); Ibicubic = imresize(Ilowres,[nrows ncols],'bicubic'); imshow(Ibicubic) title('High-Resolution Image Obtained Using Bicubic Interpolation')

Mejore la resolución de la imagen utilizando la red VDSR Preentrenada

Recuerde que el VDSR está entrenado utilizando sólo el canal de luminancia de una imagen porque la percepción humana es más sensible a los cambios de brillo que a los cambios de color.

Convierta la imagen de baja resolución del espacio de color RGB a luminancia () y a los canales de crominancia (y) mediante la función.IyIcbIcrrgb2ycbcr

Iycbcr = rgb2ycbcr(Ilowres); Iy = Iycbcr(:,:,1); Icb = Iycbcr(:,:,2); Icr = Iycbcr(:,:,3);

El lujo de los canales de luminancia y dos crominancia utilizando la interpolación bicúbica. Los canales de crominancia arriba muestreados, y, no requieren más procesamiento.Icb_bicubicIcr_bicubic

Iy_bicubic = imresize(Iy,[nrows ncols],'bicubic'); Icb_bicubic = imresize(Icb,[nrows ncols],'bicubic'); Icr_bicubic = imresize(Icr,[nrows ncols],'bicubic');

Pase el componente de luminancia a escala ascendente, a través de la red de VDSR entrenada.Iy_bicubic Observe el de la capa final (una capa de regresión).activations La salida de la red es la imagen residual deseada.

Iresidual = activations(net,Iy_bicubic,41); Iresidual = double(Iresidual); imshow(Iresidual,[]) title('Residual Image from VDSR')

Añada la imagen residual al componente de luminancia de escalado ascendente para obtener el componente de luminancia VDSR de alta resolución.

Isr = Iy_bicubic + Iresidual;

Concatenar el componente de luminancia VDSR de alta resolución con los componentes de color de escala ascendente. Convierta la imagen al espacio de color RGB utilizando la función.ycbcr2rgb El resultado es la imagen de color de alta resolución final con VDSR.

Ivdsr = ycbcr2rgb(cat(3,Isr,Icb_bicubic,Icr_bicubic)); imshow(Ivdsr) title('High-Resolution Image Obtained Using VDSR')

Comparación visual y cuantitativa

Para obtener una mejor comprensión visual de las imágenes de alta resolución, examine una región pequeña 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 la altura del ROI.

roi = [320 30 480 400];

Recorte las imágenes de alta resolución a este ROI y visualice el resultado como un montaje.

montage({imcrop(Ibicubic,roi),imcrop(Ivdsr,roi)}) title('High-Resolution Results Using Bicubic Interpolation (Left) vs. VDSR (Right)');

La imagen VDSR tiene detalles más claros y bordes más nítidos.

Utilice métricas de calidad de imagen para comparar cuantitativamente la imagen de alta resolución mediante la interpolación bicúbica con la imagen de VDSR. La imagen de referencia es la imagen de alta resolución original, antes de preparar la imagen de baja resolución de la muestra.Ireference

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

bicubicPSNR = psnr(Ibicubic,Ireference)
bicubicPSNR = 38.4747 
vdsrPSNR = psnr(Ivdsr,Ireference)
vdsrPSNR = 39.2491 

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, contra una imagen de referencia. Cuanto más cercano sea el valor de SSIM a 1, mejor será la imagen de prueba de acuerdo con la imagen de referencia. Consulte para obtener más información acerca de esta métrica.ssim

bicubicSSIM = ssim(Ibicubic,Ireference)
bicubicSSIM = 0.9861 
vdsrSSIM = ssim(Ivdsr,Ireference)
vdsrSSIM = 0.9875 

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

bicubicNIQE = niqe(Ibicubic)
bicubicNIQE = 5.1721 
vdsrNIQE = niqe(Ivdsr)
vdsrNIQE = 4.7006 

Calcule el PSNR y el SSIM promedio de todo el conjunto de imágenes de prueba para los factores de escala 2, 3 y 4. Estos son los mismos factores de escala que se utilizaron para definir el randomPatchExtraction.Datastore Para simplificar, puede usar la función auxiliar, para calcular las métricas promedio.superResolutionMetrics

superResolutionMetrics(net,testImages,scaleFactors);
Results for Scale factor 2  Average PSNR for Bicubic = 31.809683 Average PSNR for VDSR = 31.926088 Average SSIM for Bicubic = 0.938194 Average SSIM for VDSR = 0.949278  Results for Scale factor 3  Average PSNR for Bicubic = 28.170441 Average PSNR for VDSR = 28.515179 Average SSIM for Bicubic = 0.884381 Average SSIM for VDSR = 0.895356  Results for Scale factor 4  Average PSNR for Bicubic = 27.010839 Average PSNR for VDSR = 27.849618 Average SSIM for Bicubic = 0.861604 Average SSIM for VDSR = 0.877360 

Para cada factor de escala, en comparación con la interpolación bicúbica, VDSR tiene mejores puntuaciones métricas.

Resumen

En este ejemplo se muestra cómo crear y entrenar una red VDSR para varios factores de escala y, a continuación, utilizar la red para mejorar la resolución de la imagen mediante la superresolución. 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 de la red VDSR.

  • Especifique las opciones de formación.

  • Entrenar la red utilizando la función.trainNetwork

Después de entrenar la red VDSR o cargar una red VDSR preentrenada, el ejemplo realiza una superresolución en una imagen de baja resolución. En el ejemplo se compara el resultado de VDSR con la superresolución mediante la interpolación bicúbica, que no utiliza el aprendizaje profundo. VDSR supera la interpolación bicúbica con respecto a la calidad de imagen perceptual y a las mediciones cuantitativas de calidad.

Referencias

[1] Kim, J., j. k. Lee y k. m. Lee. "Superresolución de imagen precisa utilizando redes convolucionales muy profundas." .Proceedings of the IEEE® Conference on Computer Vision and Pattern Recognition 2016, PP. 1646-1654.

[2] Grubinger, M., P. Clough, H. Müller y T. Deselaers. "El IAPR TC-12 Benchmark: 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. Vol. 5, mayo 2006, p. 10.

[3] él, K., X. Zhang, S. Ren, y J. sun. "Profundizar en rectificadores: Superando el rendimiento a nivel humano en la clasificación de ImageNet. ", 2015, págs. 1026-1034.Proceedings of the IEEE International Conference on Computer Vision

Funciones de soporte

function pairedPatchesOut = extractImagePatches(imagePair,patchesPerImage,patchSize)  pairedPatchesOut = cell(patchesPerImage,2); for idx = 1:patchesPerImage     inputImage = imagePair{1};     responseImage = imagePair{2};     imgSize = size(inputImage);          % Obtain randomized indices in the input/response images that define     % the cropping rectangle     rowMin = randi(imgSize(1)-patchSize(1)+1);     colMin = randi(imgSize(2)-patchSize(2)+1);     rowIdx = rowMin:(rowMin+patchSize(1)-1);     colIdx = colMin:(colMin+patchSize(2)-1);          % Extract patch from same location in input and response image     pairedPatchesOut{idx,1} = inputImage(rowIdx,colIdx);     pairedPatchesOut{idx,2} = responseImage(rowIdx,colIdx);  end  end

Consulte también

| | | | | |

Temas relacionados