更改SRRestNet网络将其适用于接收一组低分辨率图像与单张高清图像作为一组训练对的这种多组训练对作为训练集的网络结构完整程序示例

以下是一个示例代码，展示如何修改 SRRestNet 网络结构以适用于多组训练对作为训练集的情况：

import torch.nn as nn
import torch.nn.functional as F

class SRRestNet(nn.Module):
    def __init__(self, num_training_pairs):
        super(SRRestNet, self).__init__()
        self.num_training_pairs = num_training_pairs
        
        # 定义卷积层和残差块
        self.conv1 = nn.Conv2d(3, 64, kernel_size=9, padding=4)
        self.residual_blocks = nn.Sequential(
            *[ResidualBlock(64) for _ in range(16)]
        )
        
        # 定义上采样层
        self.conv_transpose = nn.ConvTranspose2d(64, 64, kernel_size=4, stride=2, padding=1)
        
        # 定义最终输出层
        self.conv_final = nn.Conv2d(64, 3, kernel_size=3, padding=1)
        
        # 定义多组训练对的损失函数
        self.criterion = nn.MSELoss()
        
    def forward(self, *input_imgs):
        # 将多组低分辨率图像和单张高清图像拼接在一起
        input_imgs = torch.cat(input_imgs, dim=0)
        
        # 对所有图像进行 SR 网络的前向传播
        x = F.relu(self.conv1(input_imgs))
        x = self.residual_blocks(x)
        x = F.relu(self.conv_transpose(x))
        x = self.conv_final(x)
        
        # 将输出结果拆分为多组 SR 图像和单张高清图像
        sr_imgs = torch.split(x, self.num_training_pairs, dim=0)
        gt_img = sr_imgs[-1]
        sr_imgs = sr_imgs[:-1]
        
        # 返回多组 SR 图像和单张高清图像
        return sr_imgs, gt_img
    
    def compute_loss(self, sr_imgs, gt_img):
        # 计算多组 SR 图像和单张高清图像的损失
        loss = 0
        for sr_img in sr_imgs:
            loss += self.criterion(sr_img, gt_img)
        return loss / len(sr_imgs)

在这个示例中，我们在 SRRestNet 的 `__init__` 方法中添加了一个新的参数 `num_training_pairs`，表示每组训练对中包含的低分辨率图像的数量。在 `forward` 方法中，我们接收多个输入图像，并将它们拼接在一起，然后对所有图像进行 SR 网络的前向传播。最后，我们将输出结果拆分为多组 SR 图像和单张高清图像，分别返回它们。

在 `compute_loss` 方法中，我们计算多组 SR 图像和单张高清图像的损失，并返回它们的平均值作为最终损失。

使用这个修改后的 SRRestNet 网络时，你需要将每组训练对中的所有低分辨率图像和单张高清图像一起传递给网络的 `forward` 方法，如下所示：

# 创建 SRRestNet 网络
num_training_pairs = 4
sr_rest_net = SRRestNet(num_training_pairs)

# 定义优化器
optimizer = torch.optim.Adam(sr_rest_net.parameters(), lr=1e-3)

# 循环训练多个 epoch
for epoch in range(num_epochs):
    running_loss = 0.0
    for i, data in enumerate(train_dataloader, 0):
        # 将每组训练对中的所有图像拆分出来
        lr_imgs, gt_img = zip(*data)
        lr_imgs = [img for pair in lr_imgs for img in pair]  # 将多组图像拼接在一起
        gt_img = gt_img[0]  # 只有一张高清图像
        
        # 将图像传递给网络
        sr_imgs, _ = sr_rest_net(*lr_imgs, gt_img)
        
        # 计算损失并进行反向传播
        loss = sr_rest_net.compute_loss(sr_imgs, gt_img)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        # 统计损失值
        running_loss += loss.item()
    print(f"Epoch {epoch+1} loss: {running_loss / len(train_dataloader)}")

在这个示例中，我们使用了一个 `zip` 函数将每组训练对中的低分辨率图像拆分出来，并将它们拼接在一起，然后将它们和单张高清图像一起传递给网络的 `forward` 方法。在计算损失时，我们使用 SRRestNet 的 `compute_loss` 方法来计算多组 SR 图像和单张高清图像的损失。