为什么我的SRGAN（使用PyTorch）结果看起来与SRResNet结果相似？

Question

SRGAN是使用PyTorch实现的。在

发电机预培训100次，SRGAN列车200次。在

代码是现有github代码的组合。在

手电筒（）用于肾盂丢失。在

当我运行代码时，LossD收敛到0，并且LossG在某个值附近振荡。所以我停止了训练，因为我觉得不再训练了。在

如果培训如论文所述为1e5，结果会改变吗？还是功能丧失的问题？在

以下是SRGAN培训代码。在

print('Adversarial training')
for epoch in range(NUM_EPOCHS):
    train_bar = tqdm(train_loader)
    running_results = {'batch_sizes': 0, 'd_loss': 0, 'g_loss': 0, 'd_score': 0, 'g_score': 0}
    # train_bar = tqdm(train_loader)
    for data, target in train_bar:
        batch_size = data.size(0)
        running_results['batch_sizes'] += batch_size

        target_real = Variable(torch.ones(batch_size, 1))
        target_fake = Variable(torch.zeros(batch_size, 1))

        if torch.cuda.is_available():
            target_real = target_real.cuda()
            target_fake = target_fake.cuda()

        real_img = Variable(target)
        z = Variable(data)

        # Generate real and fake inputs
        if torch.cuda.is_available():
            inputsD_real = real_img.cuda()
            inputsD_fake = netG(z.cuda())
        else:
            inputsD_real = real_img
            inputsD_fake = netG(z)

        ######### Train discriminator #########
        netD.zero_grad()

        # With real data
        outputs = netD(inputsD_real)
        D_real = outputs.data.mean()

        lossD_real = adversarial_criterion(outputs, target_real)

        # With fake data
        outputs = netD(inputsD_fake.detach()) # Don't need to compute gradients wrt weights of netG (for efficiency)
        D_fake = outputs.data.mean()

        lossD_fake = adversarial_criterion(outputs, target_fake)

        lossD_total = lossD_real + lossD_fake

        lossD_total.backward()

        # Update discriminator weights
        optimizerD.step()

        ######### Train generator #########
        netG.zero_grad()

        real_features = Variable(feature_extractor(inputsD_real).data)
        fake_features = feature_extractor(inputsD_fake)

        lossG_vgg19 = content_criterion(fake_features, real_features)
        lossG_adversarial = adversarial_criterion(netD(inputsD_fake).detach(), target_real)
        lossG_mse = content_criterion(inputsD_fake, inputsD_real)

        lossG_total = lossG_mse + 2e-6 * lossG_vgg19 + 0.001 * lossG_adversarial
        lossG_total.backward()

        # Update generator weights
        optimizerG.step()