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.

Desbloqueo de imágenes JPEG mediante aprendizaje profundo

En este ejemplo se muestra cómo entrenar una red neuronal convolucional dedenota (DnCNN) y, a continuación, utilizar la red para reducir los artefactos de compresión JPEG en una imagen.

En el ejemplo se muestra cómo entrenar una red DnCNN y también se proporciona una red DnCNN previamente entrenada. Si decide entrenar la red DnCNN, se recomienda utilizar una GPU NVIDIA™ compatible con CUDA con capacidad de computación 3.0 o superior (requiere Parallel Computing Toolbox™).

Introducción

La compresión de imágenes se utiliza para reducir la huella de memoria de una imagen. Un método de compresión popular y potente es empleado por el formato de imagen JPEG, que utiliza un factor de calidad para especificar la cantidad de compresión. La reducción del valor de calidad da como resultado una mayor compresión y una menor huella de memoria, a expensas de la calidad visual de la imagen.

La compresión JPEG es , lo que significa que el proceso de compresión hace que la imagen pierda información.Lossy Para las imágenes JPEG, esta pérdida de información aparece como artefactos de bloqueo en la imagen. Como se muestra en la figura, más compresión da como resultado más pérdida de información y artefactos más fuertes. Las regiones texturizadas con contenido de alta frecuencia, como la hierba y las nubes, se ven borrosas. Los bordes afilados, como el techo de la casa y las barandillas en lo alto del faro, exhiben zumbido.

El desbloqueo JPEG es el proceso de reducir los efectos de los artefactos de compresión en imágenes JPEG. Existen varios métodos de desbloqueo JPEG, incluidos métodos más eficaces que utilizan el aprendizaje profundo. En este ejemplo se implementa uno de estos métodos basados en aprendizaje profundo que intenta minimizar el efecto de los artefactos de compresión JPEG.

La red DnCNN

En este ejemplo se utiliza una red neuronal convolucional de avance profundo integrada, denominada .DnCNN La red fue diseñada principalmente para eliminar el ruido de las imágenes. Sin embargo, la arquitectura DnCNN también se puede entrenar para eliminar artefactos de compresión JPEG o aumentar la resolución de la imagen.

El documento de referencia [ ] emplea una estrategia de aprendizaje residual, lo que significa que la red DnCNN aprende a estimar la imagen residual.1 Una imagen residual es la diferencia entre una imagen prístina y una copia distorsionada de la imagen. La imagen residual contiene información sobre la distorsión de la imagen. En este ejemplo, la distorsión aparece como artefactos de bloqueo JPEG.

La red DnCNN está entrenada para detectar la imagen residual a partir 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 combinaciones lineales diferentes de los valores de píxel rojo, verde y azul que representan información de diferencia de color.CbCr DnCNN se entrena utilizando sólo el canal de luminancia porque la percepción humana es más sensible a los cambios de brillo que los cambios de color.

Si

<math display="inline">
<mrow>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">Original</mi>
</mrow>
</msub>
</mrow>
</math>
es la luminancia de la imagen prístina y
<math display="inline">
<mrow>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">Compressed</mi>
</mrow>
</msub>
<mtext></mtext>
</mrow>
</math>
es la luminancia de la imagen que contiene artefactos de compresión JPEG, entonces la entrada a la red DnCNN es
<math display="inline">
<mrow>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">Compressed</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>
<mo>=</mo>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">Compressed</mi>
</mrow>
</msub>
<mo>-</mo>
<msub>
<mrow>
<mi mathvariant="italic">Y</mi>
</mrow>
<mrow>
<mi mathvariant="normal">Original</mi>
</mrow>
</msub>
</mrow>
</math>
de los datos de entrenamiento.

Una vez que la red DnCNN aprende a estimar una imagen residual, puede reconstruir una versión no distorsionada de una imagen JPEG comprimida añadiendo la imagen residual al canal de luminancia comprimido y, a continuación, convirtiendo la imagen al espacio de color RGB.

Descargar datos de formación

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 la red DnCNN previamente entrenada escribiendo en la línea de comandos.load('pretrainedJPEGDnCNN.mat') A continuación, vaya directamente a la sección de este ejemplo.Realizar el desbloqueo JPEG mediante la red DnCNN

Utilice la función auxiliar, , para descargar los datos.downloadIAPRTC12Data Esta función se adjunta al ejemplo como un archivo auxiliar.

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

Este ejemplo entrenará la red con un pequeño subconjunto de los datos de referencia Tc-12 de La IAPR. 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','00'); exts = {'.jpg','.bmp','.png'}; imdsPristine = imageDatastore(trainImagesDir,'FileExtensions',exts);

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

numel(imdsPristine.Files)
ans = 251 

Preparar datos de capacitación

Para crear un conjunto de datos de entrenamiento, lea imágenes prístinas y escriba imágenes en el formato de archivo JPEG con varios niveles de compresión.

Especifique los valores de calidad de imagen JPEG utilizados para representar artefactos de compresión de imágenes. Los valores de calidad deben estar en el intervalo [0, 100]. Los valores de calidad pequeños dan como resultado más compresión y artefactos de compresión más fuertes. Utilice un muestreo más denso de valores de calidad pequeños para que los datos de entrenamiento tenga una amplia gama de artefactos de compresión.

JPEGQuality = [5:5:40 50 60 70 80];

Las imágenes comprimidas se almacenan en el disco como archivos MAT en el directorio.compressedImagesDir Las imágenes residuales calculadas se almacenan en el disco como archivos MAT en el directorio.residualImagesDir Los archivos MAT se almacenan como tipo de datos para una mayor precisión al entrenar la red.double

compressedImagesDir = fullfile(imagesDir,'iaprtc12','JPEGDeblockingData','compressedImages'); residualImagesDir = fullfile(imagesDir,'iaprtc12','JPEGDeblockingData','residualImages');

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

Para cada imagen de entrenamiento prístina, la función auxiliar escribe una copia de la imagen con factor de calidad 100 para utilizarla como imagen de referencia y copias de la imagen con cada factor de calidad para utilizarla como entradas de red. La función calcula el canal de luminancia (Y) de las imágenes de referencia y comprimidas en el tipo de datos para una mayor precisión al calcular las imágenes residuales.double Las imágenes comprimidas se almacenan en el disco como . MAT en el directorio .compressedDirName Las imágenes residuales calculadas se almacenan en el disco como . MAT en el directorio .residualDirName

[compressedDirName,residualDirName] = createJPEGDeblockingTrainingSet(imdsPristine,JPEGQuality);

Crear 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 comprimidas. Las respuestas de red deseadas son las imágenes residuales. Cree un almacén de datos de imagen llamado a partir de la colección de archivos de imagen comprimidos.imdsCompressed Cree un almacén de datos de imagen llamado a partir de la colección de archivos de imagen residual calculados.imdsResidual Ambos almacenes de datos 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.

imdsCompressed = imageDatastore(compressedDirName,'FileExtensions','.mat','ReadFcn',@matRead); imdsResidual = imageDatastore(residualDirName,'FileExtensions','.mat','ReadFcn',@matRead);

Cree un que especifique los parámetros de aumento de datos.imageDataAugmenter (Deep Learning Toolbox) 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 por 90 grados y las reflexiones aleatorias en la dirección x.

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

Cree los almacenes de datos de imágenes.randomPatchExtractionDatastore Especifique un tamaño de parche de 50 por 50 píxeles. Cada imagen genera 128 parches aleatorios de tamaño 50 por 50 píxeles. Especifique un tamaño de minilote de 128.

patchSize = 50; patchesPerImage = 128; dsTrain = randomPatchExtractionDatastore(imdsCompressed,imdsResidual,patchSize, ...     'PatchesPerImage',patchesPerImage, ...     'DataAugmentation',augmenter); dsTrain.MiniBatchSize = patchesPerImage;

El almacén de datos de extracción aleatoria de parches proporciona minilotes de datos a la red en la iteración de la época.dsTrain Obtenga una vista previa del resultado de la lectura desde el almacén de datos.

inputBatch = preview(dsTrain); disp(inputBatch)
      InputImage      ResponseImage      ______________    ______________      {50×50 double}    {50×50 double}     {50×50 double}    {50×50 double}     {50×50 double}    {50×50 double}     {50×50 double}    {50×50 double}     {50×50 double}    {50×50 double}     {50×50 double}    {50×50 double}     {50×50 double}    {50×50 double}     {50×50 double}    {50×50 double} 

Configurar capas DnCNN

Cree las capas de la red DnCNN integrada mediante la función.dnCNNLayers De forma predeterminada, la profundidad de red (el número de capas de convolución) es 20.

layers = dnCNNLayers
layers =    1x59 Layer array with layers:       1   'InputLayer'             Image Input           50x50x1 images      2   'Conv1'                  Convolution           64 3x3x1 convolutions with stride [1  1] and padding [1  1  1  1]      3   'ReLU1'                  ReLU                  ReLU      4   'Conv2'                  Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]      5   'BNorm2'                 Batch Normalization   Batch normalization with 64 channels      6   'ReLU2'                  ReLU                  ReLU      7   'Conv3'                  Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]      8   'BNorm3'                 Batch Normalization   Batch normalization with 64 channels      9   'ReLU3'                  ReLU                  ReLU     10   'Conv4'                  Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     11   'BNorm4'                 Batch Normalization   Batch normalization with 64 channels     12   'ReLU4'                  ReLU                  ReLU     13   'Conv5'                  Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     14   'BNorm5'                 Batch Normalization   Batch normalization with 64 channels     15   'ReLU5'                  ReLU                  ReLU     16   'Conv6'                  Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     17   'BNorm6'                 Batch Normalization   Batch normalization with 64 channels     18   'ReLU6'                  ReLU                  ReLU     19   'Conv7'                  Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     20   'BNorm7'                 Batch Normalization   Batch normalization with 64 channels     21   'ReLU7'                  ReLU                  ReLU     22   'Conv8'                  Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     23   'BNorm8'                 Batch Normalization   Batch normalization with 64 channels     24   'ReLU8'                  ReLU                  ReLU     25   'Conv9'                  Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     26   'BNorm9'                 Batch Normalization   Batch normalization with 64 channels     27   'ReLU9'                  ReLU                  ReLU     28   'Conv10'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     29   'BNorm10'                Batch Normalization   Batch normalization with 64 channels     30   'ReLU10'                 ReLU                  ReLU     31   'Conv11'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     32   'BNorm11'                Batch Normalization   Batch normalization with 64 channels     33   'ReLU11'                 ReLU                  ReLU     34   'Conv12'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     35   'BNorm12'                Batch Normalization   Batch normalization with 64 channels     36   'ReLU12'                 ReLU                  ReLU     37   'Conv13'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     38   'BNorm13'                Batch Normalization   Batch normalization with 64 channels     39   'ReLU13'                 ReLU                  ReLU     40   'Conv14'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     41   'BNorm14'                Batch Normalization   Batch normalization with 64 channels     42   'ReLU14'                 ReLU                  ReLU     43   'Conv15'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     44   'BNorm15'                Batch Normalization   Batch normalization with 64 channels     45   'ReLU15'                 ReLU                  ReLU     46   'Conv16'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     47   'BNorm16'                Batch Normalization   Batch normalization with 64 channels     48   'ReLU16'                 ReLU                  ReLU     49   'Conv17'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     50   'BNorm17'                Batch Normalization   Batch normalization with 64 channels     51   'ReLU17'                 ReLU                  ReLU     52   'Conv18'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     53   'BNorm18'                Batch Normalization   Batch normalization with 64 channels     54   'ReLU18'                 ReLU                  ReLU     55   'Conv19'                 Convolution           64 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     56   'BNorm19'                Batch Normalization   Batch normalization with 64 channels     57   'ReLU19'                 ReLU                  ReLU     58   'Conv20'                 Convolution           1 3x3x64 convolutions with stride [1  1] and padding [1  1  1  1]     59   'FinalRegressionLayer'   Regression Output     mean-squared-error 

Seleccione Opciones de formación

Entrene la red utilizando el descenso de gradiente estocástico con optimización de impulso (SGDM). Especifique la configuración de hiperparámetropara SDGM mediante la función.trainingOptions (Deep Learning Toolbox)

Entrenar una red profunda requiere mucho tiempo. Acelere la formación especificando una alta tasa de aprendizaje. Sin embargo, esto puede hacer que los gradientes de la red exploten o crezcan incontrolablemente, evitando que la red entrene con éxito. Para mantener los degradados en un rango significativo, habilite el recorte de degradado estableciendo en , y especifique que desea utilizar el valor absoluto de los degradados.'GradientThreshold'0.005'GradientThresholdMethod'

maxEpochs = 30; initLearningRate = 0.1; l2reg = 0.0001; batchSize = 64;  options = trainingOptions('sgdm', ...     'Momentum',0.9, ...     'InitialLearnRate',initLearningRate, ...     'LearnRateSchedule','piecewise', ...     'GradientThresholdMethod','absolute-value', ...     'GradientThreshold',0.005, ...     'L2Regularization',l2reg, ...     'MiniBatchSize',batchSize, ...     'MaxEpochs',maxEpochs, ...     'Plots','training-progress', ...     'Verbose',false);

Entrenar la red

Después de configurar las opciones de entrenamiento y el almacén de datos de extracción aleatoria de parches, entrene la red DnCNN mediante la función.trainNetwork (Deep Learning Toolbox) 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 una red DnCNN entrenada previamente.doTrainingfalse

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

% Training runs when doTraining is true doTraining = false;  if doTraining       modelDateTime = datestr(now,'dd-mmm-yyyy-HH-MM-SS');     [net,info] = trainNetwork(dsTrain,layers,options);     save(['trainedJPEGDnCNN-' modelDateTime '-Epoch-' num2str(maxEpochs) '.mat'],'net','options'); else      load('pretrainedJPEGDnCNN.mat');  end

Ahora puede utilizar la red DnCNN para eliminar artefactos de compresión JPEG de nuevas imágenes.

Realizar el desbloqueo JPEG mediante la red DnCNN

Para realizar el desbloqueo JPEG mediante DnCNN, siga los pasos restantes de este ejemplo. El resto del ejemplo muestra cómo:

  • Cree imágenes de prueba de ejemplo con artefactos de compresión JPEG en tres niveles de calidad diferentes.

  • Quite los artefactos de compresión mediante la red DnCNN.

  • Compare visualmente las imágenes antes y después del desbloqueo.

  • Evalúe la calidad de las imágenes comprimidas y desbloqueadas cuantificando su similitud con la imagen de referencia no distorsionada.

Crear imágenes de muestra con artefactos de bloqueo

Cree imágenes de ejemplo para evaluar el resultado del desbloqueo de imágenes JPEG mediante la red DnCNN. El conjunto de datos de prueba, , contiene 21 imágenes sin distorsión enviadas 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 desbloqueo JPEG. Opcionalmente, puede utilizar su propia imagen sin comprimir como imagen de referencia.

indx = 7; % Index of image to read from the test image datastore Ireference = readimage(testImages,indx); imshow(Ireference) title('Uncompressed Reference Image')

Cree tres imágenes de prueba comprimidas con los valores JPEG de 10, 20 y 50.Quality

imwrite(Ireference,fullfile(tempdir,'testQuality10.jpg'),'Quality',10); imwrite(Ireference,fullfile(tempdir,'testQuality20.jpg'),'Quality',20); imwrite(Ireference,fullfile(tempdir,'testQuality50.jpg'),'Quality',50);

Preprocesar imágenes comprimidas

Lea las versiones comprimidas de la imagen en el espacio de trabajo.

I10 = imread(fullfile(tempdir,'testQuality10.jpg')); I20 = imread(fullfile(tempdir,'testQuality20.jpg')); I50 = imread(fullfile(tempdir,'testQuality50.jpg'));

Muestre las imágenes comprimidas como un montaje.

montage({I50,I20,I10},'Size',[1 3]) title('JPEG-Compressed Images with Quality Factor: 50, 20 and 10 (left to right)')

Recuerde que DnCNN 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 los cambios de color. Convierta las imágenes comprimidas en JPEG del espacio de color RGB al espacio de color YCbCr mediante la función.rgb2ycbcr

I10ycbcr = rgb2ycbcr(I10); I20ycbcr = rgb2ycbcr(I20); I50ycbcr = rgb2ycbcr(I50);

Aplicar la red DnCNN

Para realizar el paso hacia adelante de la red, utilice la función.denoiseImage Esta función utiliza exactamente los mismos procedimientos de entrenamiento y prueba para denotar una imagen. Puede pensar en los artefactos de compresión JPEG como un tipo de ruido de imagen.

I10y_predicted = denoiseImage(I10ycbcr(:,:,1),net); I20y_predicted = denoiseImage(I20ycbcr(:,:,1),net); I50y_predicted = denoiseImage(I50ycbcr(:,:,1),net);

Los canales de crominancia no necesitan procesamiento. Concatenar el canal de luminancia desbloqueado con los canales de crominancia originales para obtener la imagen desbloqueada en el espacio de color YCbCr.

I10ycbcr_predicted = cat(3,I10y_predicted,I10ycbcr(:,:,2:3)); I20ycbcr_predicted = cat(3,I20y_predicted,I20ycbcr(:,:,2:3)); I50ycbcr_predicted = cat(3,I50y_predicted,I50ycbcr(:,:,2:3));

Convierta la imagen YCbCr desbloqueada al espacio de color RGB mediante la función.ycbcr2rgb

I10_predicted = ycbcr2rgb(I10ycbcr_predicted); I20_predicted = ycbcr2rgb(I20ycbcr_predicted); I50_predicted = ycbcr2rgb(I50ycbcr_predicted);

Muestre las imágenes desbloqueadas como un montaje.

montage({I50_predicted,I20_predicted,I10_predicted},'Size',[1 3]) title('Deblocked Images with Quality Factor 50, 20 and 10 (Left to Right)')

Para obtener una mejor comprensión visual de las mejoras, examine una región más 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 altura del ROI.

roi = [30 440 100 80];

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

i10 = imcrop(I10,roi); i20 = imcrop(I20,roi); i50 = imcrop(I50,roi); montage({i50 i20 i10},'Size',[1 3]) title('Patches from JPEG-Compressed Images with Quality Factor 50, 20 and 10 (Left to Right)')

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

i10predicted = imcrop(I10_predicted,roi); i20predicted = imcrop(I20_predicted,roi); i50predicted = imcrop(I50_predicted,roi); montage({i50predicted,i20predicted,i10predicted},'Size',[1 3]) title('Patches from Deblocked Images with Quality Factor 50, 20 and 10 (Left to Right)')

Comparación cuantitativa

Cuantifique la calidad de las imágenes desbloqueadas a través de cuatro métricas. Puede utilizar la función auxiliar para calcular estas métricas para imágenes comprimidas y desbloqueadas con los factores de calidad 10, 20 y 50.displayJPEGResults Esta función se adjunta al ejemplo como un archivo auxiliar.

  • Indice de Similitud Estructural (SSIM). 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. Aquí, la imagen de referencia es la imagen original no distorsionada, , antes de la compresión JPEG.Ireference Consulte para obtener más información acerca de esta métrica.ssim

  • Relación señal-ruido pico (PSNR). Cuanto mayor sea el valor PSNR, más fuerte será la señal en comparación con la distorsión. Consulte para obtener más información acerca de esta métrica.psnr

  • Evaluador de Calidad de Imagen natural (NIQE). NIQE mide la calidad de imagen perceptiva utilizando un modelo entrenado a partir de escenas naturales. 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

  • Evaluador de Calidad Espacial de Imagen Ciego/Sin Referencia (BRISQUE). BRISQUE mide la calidad de imagen perceptiva utilizando un modelo entrenado a partir de escenas naturales con distorsión de imagen. Las puntuaciones BRISQUE más pequeñas indican una mejor calidad perceptiva. Consulte para obtener más información acerca de esta métrica.brisque

displayJPEGResults(Ireference,I10,I20,I50,I10_predicted,I20_predicted,I50_predicted)
------------------------------------------ SSIM Comparison =============== I10: 0.90624    I10_predicted: 0.91286 I20: 0.94904    I20_predicted: 0.95444 I50: 0.97238    I50_predicted: 0.97482 ------------------------------------------ PSNR Comparison =============== I10: 26.6046    I10_predicted: 27.0793 I20: 28.8015    I20_predicted: 29.3378 I50: 31.4512    I50_predicted: 31.8584 ------------------------------------------ NIQE Comparison =============== I10: 7.2194    I10_predicted: 3.9478 I20: 4.5158    I20_predicted: 3.0685 I50: 2.8874    I50_predicted: 2.4106 NOTE: Smaller NIQE score signifies better perceptual quality ------------------------------------------ BRISQUE Comparison ================== I10: 52.372    I10_predicted: 38.9271 I20: 45.3772    I20_predicted: 30.8991 I50: 27.7093    I50_predicted: 24.3845 NOTE: Smaller BRISQUE score signifies better perceptual quality 

Resumen

En este ejemplo se muestra cómo crear y entrenar una red DnCNN y, a continuación, utilizar la red para reducir los artefactos de compresión JPEG en las imágenes. Estos fueron los pasos para entrenar la red:

  • Descargue los datos de entrenamiento.

  • Cree imágenes de entrenamiento escribiendo imágenes prístinas en el formato de archivo JPEG con varios niveles de compresión.

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

  • Cree las capas de la red DnCNN mediante la función.dnCNNLayers

  • Especifique las opciones de entrenamiento.

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

Después de entrenar la red DnCNN o cargar una red DnCNN previamente entrenada, el ejemplo comprime una imagen de prueba en tres valores de calidad y, a continuación, utiliza la red para quitar los artefactos de compresión.

Referencias

[1] Zhang, K., W. Zuo, Y. Chen, D. Meng y L. Zhang, "Más allá de un Denoiser gaussiano: Aprendizaje Residual de CNN Profunda para Denoising de Imagen." .IEEE® Transactions on Image Processing Febrero de 2017.

[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)

Temas relacionados