介绍
想象一下，你在一个尘土飞扬的阁楼里发现了一本旧的家庭相册。你会立即清理灰尘，并充满兴奋地翻阅它的页面。你发现了一张很多年前的照片。但是，你看起来并不开心，因为这张照片已经模糊而且颜色已经褪色。你会竭尽全力去找到照片中的面孔和细节。这是在旧时代的场景。幸好，现在有了新技术。我们有超分辨率生成对抗网络（SRGAN），可以将低分辨率图像转换为高分辨率图像。在本文中，我们将学习最多关于SRGAN，并将其应用于QR码增强。
学习目标
在本文中，我们将学习：
- 超分辨率及其与普通缩放的区别
- 超分辨率的一些方法及其类型
- 深入了解SRGAN，它们的损失函数、架构和一些应用
- 使用SRGAN进行QR增强的实现以及详细描述
本文是数据科学博客马拉松的一部分。
什么是超分辨率？
在许多犯罪调查电影中，我们经常遇到一个典型的情景，侦探会检查闭路电视录像以获取证据。有一幕场景，有人发现了一张小而模糊的图像，他们通过缩放和增强得到了清晰的图片。你觉得这可能吗？是的，我们可以通过超分辨率来做到这一点。超分辨率技术可以增强由闭路电视摄像机捕捉的模糊图像，从而为它们提供更详细的视觉效果。
…………………………………………………………………………………………………………………………………………………………..
…………………………………………………………………………………………………………………………………………………………..
将图像进行放大和增强的过程称为超分辨率。它包括从相应的低分辨率输入生成图像或视频的高分辨率版本。其目标是恢复丢失的细节，提高清晰度并改善视觉质量。如果你只是放大图片而不进行增强，你会得到模糊的图片，如下图所示。增强是通过超分辨率实现的。它在许多领域中都有应用，包括摄影、监视系统、医学成像、卫星成像等。
………..
传统超分辨率方法
传统方法主要集中于估计缺失的像素值和提高图像分辨率。有两种方法：基于插值的方法和基于正则化的方法。
基于插值的方法
在超分辨率的早期阶段，他们主要关注基于插值的方法，其目标是估计缺失的像素值，然后将图像放大。假设相邻的像素值将具有相似的像素值，并使用这些值来估计缺失的值。最常用的插值方法包括双三次插值、双线性插值和最近邻插值。但是结果不尽如人意。这导致了模糊的图像。这些方法计算高效，适用于基本的分辨率任务和计算资源有限的情况。
基于正则化的方法
另一方面，基于正则化的方法旨在通过将额外的约束或先验引入到图像重建过程中来改善超分辨率结果。这些技术利用图像的统计特征来增加重建图像的精度，同时保留细节。它提供了更多对重建过程的控制，并增强了图像的清晰度和细节。但是，这里存在一些限制，如处理复杂图像内容会导致在某些情况下过度平滑。
尽管这些传统方法有一些限制，但它们为超分辨率强大的方法的出现铺平了道路。
基于学习的超分辨率方法
基于学习的方法已成为超分辨率的强大有效解决方案。它允许生成高度详细的高分辨率图像。有两种主要的基于学习的方法：单图像超分辨率（SISR）和生成对抗网络（GANs）。
单图像超分辨率
单图像超分辨率专注于学习一个直接从低分辨率图像到高分辨率图像的映射函数。它使用卷积神经网络（CNNs）。研究人员使用包括低分辨率和高分辨率图像对的大规模数据集来训练这些网络。这些网络学习低关系和高关系图像之间的潜在模式和关系，以便生成高质量的结果。SISR模型的架构包括编码器和解码器。
这里编码器捕捉低分辨率图像的特征，然后通过解码器进行缩放并优化这些特征以获得高分辨率图像。用于测量真实和生成图像之间差异的常用损失指标包括均方误差（MSE）和峰值信噪比（PSNR）。通过在训练过程中最小化这些损失函数，网络将学习生成与原始高分辨率图像非常相似的高分辨率图像。
生成对抗网络（GANs）
另一方面，生成对抗网络（GANs）引入了对抗性学习框架，并在超分辨率方面取得了进展。GANs由两部分组成。它们包括鉴别器网络和生成器网络。生成器网络以低分辨率图像为输入，试图产生高分辨率输出。鉴别器网络试图区分人工创建的高分辨率图像和实际高分辨率图像。基于GAN的超分辨率方法在生成逼真图像方面显示出令人印象深刻的结果。与传统方法相比，它们更能够捕获复杂模式并创建细节纹理。超分辨率生成对抗网络（SRGANs）是GANs的流行实现之一，用于超分辨率任务。
超分辨率生成对抗网络（SRGAN）
在当今世界中，高质量的图像在许多领域中都非常重要。但由于许多限制，不总是可能拍摄高分辨率图像。这时超分辨率变得相关。它将低分辨率内容转换为高分辨率内容。为了克服传统方法的限制，出现了基于学习的超分辨率方法，使用GANs是其中之一。
SRGAN是生成对抗网络（GANs）和深度卷积神经网络（CNNs）的组合，它可以从低分辨率图像生成高度逼真的高分辨率图像。我们知道，生成对抗网络（SRGAN）由两部分组成。它们是生成器和鉴别器。生成器和鉴别器都通过相互对抗学习。我们知道，生成器的目标是生成无法与真实高分辨率图像区分的高分辨率图像。鉴别器的目标是区分生成器图像和真实图像。这被称为对抗性训练。生成器始终试图通过生成超逼真的高分辨率图像来欺骗鉴别器。它学会了捕捉图像中非常细微的细节和整体视觉特征。鉴别器在生成的图像上向生成器提供反馈，通过反向传播，生成器学习更好，试图最小化损失。
感知损失
在SRGANs的情况下使用损失函数，即感知损失，它是两种不同损失的组合。它们是内容损失和对抗损失。
- 内容损失：在SRGAN出现之前，使用y_fake和y_real之间的均方误差来计算损失函数。但是，即使可以实现高信噪比，这种方法也会损失很多高频信息。因此，论文的作者决定采用几个VGG层的损失。预训练的19层VGG网络的ReLU激活层构成了这种VGG损失的基础，它是特征表示之间的欧几里得距离。训练后，我们从VGG模型的特定层提取特征图。将特征映射与实际图像进行比较。
- 对抗损失：使用对抗损失可以鼓励生成器产生高度逼真的超分辨率图像。对抗损失的计算基于鉴别器的预测。生成器试图将此损失最小化，而鉴别器试图将其最大化。通过包括对抗损失，SRGANs允许生成器网络学习和创建视觉上看起来像实际高分辨率图像的超分辨率图像。
超分辨率的整体损失（感知损失）为：
SRGAN的架构
生成器架构
它从低分辨率图像作为输入开始，将该输入图像通过使用9乘9的64个滤波器的卷积层。接下来，parametric ReLU函数将其作为输入接收。然后将值发送到残差块，其中将常见操作分组在一起，形成残差块。该操作序列在通过每个块时重复。在残差块内，我们有一个使用3乘3的64个像素的卷积层。接下来是parametric ReLU，再应用批归一化层。然后是另一个卷积层，它又是在批归一化之后。
最后，使用残差块的输入执行元素总和。该块的输出被发送到下一个块，并重复相同的步骤。这将持续到最后一个残差块。如作者在原始论文中所述，SRGAN中总共有16个残差块。这些残差块的目的是从输入图像中提取特征。
在残差块之后，我们有另一个卷积层和批次归一化层。接下来，再次对第一个参数化ReLU函数的输出执行元素总和。接下来是上采样块，其中进行像素重组以逐渐增加图像的分辨率。它有两个上采样块。最后以卷积层结束，生成超分辨率图像作为输出。
鉴别器架构
鉴别器网络只是一个图像分类卷积神经网络（CNN）。它负责区分生成的图像和真实高分辨率图像。它学习对输入图像进行分类。首先，对输入图像应用卷积层，无论是真实的高分辨率图像还是生成器生成的高分辨率图像。此层从输入图像中提取特征，然后通过Leaky ReLU函数传递。通过几个包含卷积层、批量归一化和Leaky ReLU的鉴别器块进行传递。最后，它通过稠密层，接着是Leaky ReLu和另一个稠密层，以获得输出。我们知道这是原始高分辨率图像和生成器生成的高分辨率图像之间的分类。
SRGAN的应用
- 图像和视频放大：SRGAN的第一个和最重要的应用是图像和视频放大。这在数字媒体、娱乐等各个领域非常有用，其中质量起着重要的作用。SRGAN可以提高低分辨率内容的细节、锐度和整体视觉质量。
- 监控和安全：在监控和安全方面，SRGAN被用于通过提高低分辨率的闭路电视（CCTV）图像来提供高分辨率的画面。这有助于通过改善重要细节（如车牌、嫌疑人图像等）的清晰度来进行更好和更快的调查。
- 医学成像：SRGAN在医学成像领域展示了出色的结果。它们被用于改善低分辨率的医学图像，如MRI扫描或超声图像，并提高了诊断准确性。获取高分辨率图像有助于医生理解病人问题的更细节，并有助于提供更好的治疗。
- 卫星图像：由于技术限制，卫星图像始终具有较低的分辨率。因此，SRGAN被用于放大这些低分辨率图像，这允许更好地分析和更好地理解地理特征、天气模式等等。
使用SRGAN进行QR增强的实现
在这个项目中，我们将使用SRGAN进行实现。这个项目是关于QR码增强，其中低分辨率和模糊的QR码图像将作为输入，我们的模型将给出QR码的高分辨率清晰图片。
您可以在此处下载QR码数据集。
让我们首先导入一些所需的库。
import tensorflow as tf
import numpy as np
import pandas as pd
import cv2
import os
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras import layers, Model
from sklearn.model_selection import train_test_split
from keras import Model
from keras.layers import Conv2D
from keras.layers import PReLU
from keras.layers import BatchNormalization
from keras.layers import Flatten
from keras.layers import UpSampling2D
from keras.layers import LeakyReLU
from keras.layers import Dense
from keras.layers import Input
from keras.layers import add
from tqdm import tqdm使用pip安装所有缺失的包。
!pip install opencv-python
!pip install tqdm
!pip install scikit-image现在迭代目录中的文件，使用OpenCV读取图像文件，并使用matplotlib显示它。因此，首先分配存储图像的路径。我们将在一次迭代后停止循环。因此，只显示一个图像。
datadir = r'数据集路径'
# 迭代一个元素
for img in os.listdir(datadir):
img_array = cv2.imread(os.path.join(datadir,img) ,cv2.IMREAD_GRAYSCALE)
plt.imshow(img_array, cmap='gray')
plt.show()
break 
创建训练数据
现在，我们必须处理目录中的所有图像并创建训练数据。为此，我们必须声明两个列表：array和array_small。这些被初始化为存储调整大小后的图像。导入“tqdm”模块以在迭代图像时显示进度条。在create_training_data函数中，我们将迭代目录中的每个图像。对于每个图像，首先使用imread()读取它，然后使用resize()函数将其调整为（128，128）。然后将调整大小的图像附加到数组列表中。然后将其调整为（32，32）并将其附加到array_small列表中。对目录中的每个图像重复此过程。
array = []
array_small =[]
from tqdm import tqdm
def create_training_data():
for img in tqdm(list(os.listdir(datadir))): # 迭代每个图像
try:
img_array = cv2.imread(datadir+'/'+img ,cv2.IMREAD_COLOR) # 转换为数组
new_array = cv2.resize(img_array, (128, 128)) # 调整大小以规范化数据大小
array.append([new_array])
array_small.append([cv2.resize(img_array, (32,32),
interpolation=cv2.INTER_AREA)]) # 将其添加到我们的训练数据中
except Exception as e: # 为了保持输出的可读性……
pass
create_training_data()
让我们找到数组的长度。这意味着我们总共有10000张图片。
len(array)
#10000为了检查图像处理和调整大小步骤是否成功，我们需要创建两个空列表：X和Xs。将所有高分辨率图像附加到X中，将所有低分辨率图像附加到Xs中。然后绘制一个同时包含高分辨率和低分辨率图像的图像。在此之前，将两个列表都转换为数组。
X = []
Xs = []
for features in array:
X.append(features)
for features in array_small:
Xs.append(features)
plt.figure(figsize=(16, 8))
X = np.array(X).reshape(-1, 128, 128, 3)
Xs = np.array(Xs).reshape(-1, 32, 32, 3)
plt.subplot(231)
plt.imshow(X[0], cmap = 'gray')
plt.subplot(233)
plt.imshow(Xs[0], cmap = 'gray')
plt.show()
数据增强
让我们增加整个数据。我们可以使用ImageDataGenerator()来创建增强图像。创建图像后，重塑它们并将它们保存到一个单独的目录中。
#augmenting the data
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from skimage import io
datagen = ImageDataGenerator(
rotation_range = 40,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True,
brightness_range = (0.5, 1.5))
for a in X:
i = 0
a = a.reshape((1, ) + a.shape)
for batch in datagen.flow(a, batch_size=1, save_to_dir= r'C:\Users\Admin\Downloads\QR\augmented',
save_prefix='ag', save_format='png'):
try:
i += 1
if i>= 10:
break
except Exception:
print("error")
pass我们必须为增强的图像创建类似于原始数据的训练数据。然后创建两个更多的列表：X1和Xs1，用于存储增强数据，然后绘制图以了解情况。然后将原始数据列表和增强数据列表连接在一起。
array=[]
array_small=[]
datadir = r'C:\Users\Admin\Downloads\QR\augmented'
create_training_data()
X1 = []
Xs1 = []
for features in array:
X1.append(features)
for features in array_small:
Xs1.append(features)
X1 = np.array(X1).reshape(-1, 128, 128, 3)
Xs1 = np.array(Xs1).reshape(-1, 32, 32, 3)
plt.figure(figsize=(16, 8))
plt.subplot(231)
plt.imshow(X1[0], cmap = 'gray')
plt.subplot(233)
plt.imshow(Xs1[0], cmap = 'gray')
plt.show()
X=np.concatenate((X,X1), axis = 0)
Xs=np.concatenate((Xs,Xs1), axis=0)
X.shape
现在是将整个数据拆分为训练和验证集的时候了。test_size表示应将33％的数据分配给验证集，而67％则分配给训练集。random_state设置随机种子以确保拆分的可重现性。
from sklearn.model_selection import train_test_split
X_train,X_valid,y_train, y_valid = train_test_split(Xs, X, test_size = 0.33, random_state = 12)
X_train.shape定义生成器
让我们构建生成器。首先定义残差块，它是许多深度学习体系结构中的基本构建块。然后定义升级块，它负责增加输入张量的分辨率。最后，定义一个生成器，它需要3个输入参数。它们是输入和额外参数res_range和upscale_range，用于控制网络中残差块和升级块的数量。
def res_block(input_dim):
model = Conv2D(64, (3,3), padding = 'same' )(input_dim)
model = BatchNormalization()(model)
model = PReLU(shared_axes = [1,2])(model)
model = Conv2D(64, (3,3), padding = 'same' )(model)
model = BatchNormalization()(model)
return add([input_dim, model])
def upscale_block(input_dim):
model = Conv2D(256,(3,3), strides=1, padding = 'same')(input_dim)
model = UpSampling2D(size = (2,2))(model)
model = PReLU(shared_axes=[1, 2])(model)
return model
def generator(input, res_range = 1,upscale_range=1):
model = Conv2D(64,(9,9), strides=1, padding = 'same')(input)
model = PReLU(shared_axes = [1,2])(model)
model1 = model
for i in range(res_range):
model = res_block(model)
model = Conv2D(64, (3,3), padding = 'same' )(model)
model = BatchNormalization()(model)
model = add([model,model1])
for i in range(upscale_range):
model =upscale_block(model)
output = Conv2D(3, (9,9), padding='same')(model)
return Model(input, output)定义判别器
现在让我们构建GAN的第二部分——判别器。首先定义判别器块（discriminator block），它是判别器中使用的卷积块。接下来定义判别器网络。它采用一个64个滤波器和kernel size为（3,3）的2D卷积，应用LeakyReLU激活函数，添加一些判别器块，展平输出张量，应用具有1024个单位的全连接层，应用alpha为0.2的LeakyReLU激活函数，并输出一个具有sigmoid激活函数的单个单位，表示判别器的输出。最后，该函数返回一个带有输入和输出张量的Keras“Model”对象。
def discrim_block(input_dim, fmaps = 64, strides = 1):
model = Conv2D(fmaps, (3,3), padding = 'same', strides = strides)(input_dim)
model = BatchNormalization()(model)
model = LeakyReLU()(model)
return model
def discriminator(input):
model = Conv2D(64,(3,3),padding='same')(input)
model = LeakyReLU()(model)
model = discrim_block(model, strides = 2)
model = discrim_block(model, fmaps = 128)
model = discrim_block(model, fmaps = 128, strides = 2)
model = discrim_block(model, fmaps=256)
model = discrim_block(model, fmaps=256, strides=2)
model = discrim_block(model, fmaps=512)
model = discrim_block(model, fmaps=512, strides=2)
model = Flatten()(model)
model = Dense(1024)(model)
model = LeakyReLU(alpha = 0.2)(model)
out = Dense(1, activation='sigmoid')(model)
return Model(input, out)定义VGG模型
我们的下一步是构建一个VGG模型。它使用VGG19函数初始化一个在ImageNet数据集上预训练的VGG19模型。最后，该函数返回一个带有输入和输出张量的Keras Model对象。
然后，我们必须创建一个具有生成器、判别器和VGG19层的组合模型。它的输入为：生成器模型、判别器模型、VGG19模型、低分辨率输入和高分辨率输入。它通过生成器模型将低分辨率输入传递给生成高分辨率输出。接下来，使用VGG19模型（vgg）从生成的高分辨率图像中提取特征。判别器模型设置为不可训练，因为意图仅训练模型的生成器部分。通过将生成的图像（gen_img）通过判别器模型（disc_model），计算生成图像的有效性。通过组合生成器、判别器和VGG19层，得到的模型可以用于训练生成器生成高分辨率图像。
#介绍vgg19层
from tensorflow.keras.applications.vgg19 import VGG19
def build_vgg(hr_shape):
vgg = VGG19(weights="imagenet", include_top=False, input_shape=hr_shape)
return Model(inputs=vgg.inputs, outputs=vgg.layers[10].output)
#定义组合模型
def create_comb(gen_model, disc_model, vgg, lr_ip, hr_ip):
gen_img = gen_model(lr_ip)
gen_features = vgg(gen_img)
disc_model.trainable = False
validity = disc_model(gen_img)
return Model(inputs=[lr_ip, hr_ip], outputs=[validity, gen_features])构建SRGAN
现在创建最终的生成器网络。为此，请设置所有输入，构建生成器、鉴别器和VGG19层，最后创建组合模型（GAN模型）。因此，首先将高分辨率训练图像的形状设置为y_train，并将低分辨率训练图像的形状设置为X_train。然后使用生成器和鉴别器函数分别创建生成器和鉴别器。使用build_vgg函数创建VGG19层。最后，使用create_comb函数创建GAN模型。GAN模型将生成器、鉴别器和VGG19层组合成单个模型进行训练。
hr_shape = (y_train.shape[1], y_train.shape[2], y_train.shape[3])
lr_shape = (X_train.shape[1], X_train.shape[2], X_train.shape[3])
lr_ip = Input(shape=lr_shape)
hr_ip = Input(shape=hr_shape)
generator = generator(lr_ip, res_range = 16, upscale_range=2)
generator.summary()
discriminator = discriminator(hr_ip)
discriminator.compile(loss="binary_crossentropy", optimizer="adam", metrics=['accuracy'])
discriminator.summary()
vgg = build_vgg((128,128,3))
print(vgg.summary())
vgg.trainable = False
gan_model = create_comb(generator, discriminator, vgg, lr_ip, hr_ip)使用二元交叉熵和均方误差损失函数以及Adam优化器编译SRGAN。对于鉴别器输出（validity），使用第一个损失函数，对于生成器输出（gen_features），使用第二个损失函数。
gan_model.compile(loss=["binary_crossentropy", "mse"], loss_weights=[1e-3, 1], optimizer="adam")
gan_model.summary()将训练数据划分为批次以训练SRGAN模型。创建了两个空列表，train_lr_batches和train_hr_batches，用于分别存储低分辨率和高分辨率图像批次。在循环内，从y_train数据集中提取高分辨率图像批次（y_train[start_idx:end_idx]），并将其附加到train_hr_batches列表中。类似地，从X_train数据集中提取低分辨率图像批次（X_train[start_idx:end_idx]）并将其附加到train_lr_batches列表中。
batch_size = 1
train_lr_batches = []
train_hr_batches = []
for it in range(int(y_train.shape[0] / batch_size)):
start_idx = it * batch_size
end_idx = start_idx + batch_size
train_hr_batches.append(y_train[start_idx:end_idx])
train_lr_batches.append(X_train[start_idx:end_idx])训练
我们的下一步是训练这个SRGAN模型。迭代次数为epochs。创建fake_label，它是一个填充了零的numpy数组，表示伪造（生成）图像的标签，和real_label，它是一个填充了一的numpy数组，表示真实图像的标签。然后创建两个空列表，g_losses和d_losses，用于分别存储生成器和鉴别器的损失。
在此过程中，生成器生成伪造图像，并使用伪造图像和真实图像训练鉴别器。 VGG网络负责从高分辨率图像中提取特征。在遍历所有批次后，我们计算平均生成器和鉴别器损失。通过以对抗的方式更新鉴别器和生成器并跟踪它们的损失来训练SRGAN模型。
epochs = 1
#枚举训练的迭代次数
for e in range(epochs):
fake_label = np.zeros((batch_size, 1))
real_label = np.ones((batch_size,1))
g_losses = []
d_losses = []
#枚举训练的批次
for b in tqdm(range(len(train_hr_batches))):
lr_imgs = train_lr_batches[b]
hr_imgs = train_hr_batches[b]
fake_imgs = generator.predict_on_batch(lr_imgs)
discriminator.trainable = True
d_loss_gen = discriminator.train_on_batch(fake_imgs, fake_label)
d_loss_real = discriminator.train_on_batch(hr_imgs, real_label)
discriminator.trainable = False
d_loss = 0.5 * np.add(d_loss_gen, d_loss_real)
image_features = vgg.predict(hr_imgs)
g_loss, _, _ = gan_model.train_on_batch([lr_imgs, hr_imgs], [real_label, image_features])
d_losses.append(d_loss)
g_losses.append(g_loss)
g_losses = np.array(g_losses)
d_losses = np.array(d_losses)
g_loss = np.sum(g_losses, axis=0) / len(g_losses)
d_loss = np.sum(d_losses, axis=0) / len(d_losses)
print("epoch:", e+1 ,"g_loss:", g_loss, "d_loss:", d_loss)
if (e+1) % 5 == 0:
generator.save("gen_e_"+ str(e+1) +".h5")保存已训练的生成器模型。
generator.save("generator"+ str(e+1) +".h5")测试
我们的最后一步是检查我们的SRGAN。现在，让我们使用训练好的生成器模型生成超分辨率图像，并将它们与低分辨率和原始高分辨率图像进行比较。
from tensorflow.keras.models import load_model
from numpy.random import randint
[X1, X2] = [X_valid, y_valid]
ix = randint(0, len(X1), 1)
src_image, tar_image = X1[ix], X2[ix]
gen_image = generator.predict(src_image)
plt.figure(figsize=(16, 8))
plt.subplot(231)
plt.title('低分辨率图像')
plt.imshow(src_image[0,:,:,:], cmap = 'gray')
plt.subplot(232)
plt.title('超分辨率图像')
plt.imshow(cv2.cvtColor(gen_image[0,:,:,:], cv2.COLOR_BGR2GRAY),cmap = 'gray')
plt.subplot(233)
plt.title('原始高分辨率图像')
plt.imshow(tar_image[0,:,:,:], cmap = 'gray')
plt.show()
结论
我们已成功实现了QR码增强的SRGAN。我们得到的结果只经过了一次迭代。我们可以观察到分辨率的变化，它几乎达到了原始高分辨率图像。想象一下，如果我们训练了至少10个epoch，那将是SRGAN的威力。SRGAN已经成为图像超分辨率领域的变革者。这些是生成超分辨率图像最先进和最强大的模型。
关键点
- SRGANs（Super-Resolution Generative Adversarial Networks）是超分辨率任务的最新方法。
- 它使用感知损失，这是内容损失和对抗损失的组合。这有助于生成高度逼真的高分辨率图像。
- 研究人员和开发人员可以访问预训练的SRGAN模型，如ESRGAN、SRResNet和SRGAN（原始）。通过微调这些模型，可将其用于其任务。
- 到目前为止，我们已经获得了关于SRGAN的很多知识，并且通过将其用于QR增强，结果令人惊叹。
- 随着研究人员继续探索和修改SRGAN的架构、损失函数和训练策略，我们可以期待未来有更令人印象深刻的结果。
常见问题解答
如果您有任何问题，请在LinkedIn上与我联系。
本文中展示的媒体不归Analytics Vidhya所有，仅由作者自己决定使用。