这是我要实现的目标：
我们照常根据F(X)计算损失。但是我们还定义了“对抗性损失”，即基于F(X + e)的损失。 e定义为dF(X)/dX乘以某个常数。损失和对抗性损失都向后传播，以弥补全部损失。
在tensorflow中，该部分（得到dF(X)/dX）可以像下面这样编码：
grad, = tf.gradients( loss, X )
grad = tf.stop_gradient(grad)
e = constant * grad
下面是我的pytorch代码：
class DocReaderModel(object):
def __init__(self, embedding=None, state_dict=None):
self.train_loss = AverageMeter()
self.embedding = embedding
self.network = DNetwork(opt, embedding)
self.optimizer = optim.SGD(parameters)
def adversarial_loss(self, batch, loss, embedding, y):
self.optimizer.zero_grad()
loss.backward(retain_graph=True)
grad = embedding.grad
grad.detach_()
perturb = F.normalize(grad, p=2)* 0.5
self.optimizer.zero_grad()
adv_embedding = embedding + perturb
network_temp = DNetwork(self.opt, adv_embedding) # This is how to get F(X)
network_temp.training = False
network_temp.cuda()
start, end, _ = network_temp(batch) # This is how to get F(X)
del network_temp # I even deleted this instance.
return F.cross_entropy(start, y[0]) + F.cross_entropy(end, y[1])
def update(self, batch):
self.network.train()
start, end, pred = self.network(batch)
loss = F.cross_entropy(start, y[0]) + F.cross_entropy(end, y[1])
loss_adv = self.adversarial_loss(batch, loss, self.network.lexicon_encoder.embedding.weight, y)
loss_total = loss + loss_adv
self.optimizer.zero_grad()
loss_total.backward()
self.optimizer.step()
我有几个问题：
1）我用grad.detach_（）代替了tf.stop_gradient。这是正确的吗？
2）我得到"RuntimeError: Trying to backward through the graph a second time, but the buffers have already been freed. Specify retain_graph=True when calling backward the first time."，所以我在retain_graph=True处添加了loss.backward。该特定错误消失了。
但是，现在经过几个纪元（{{1}
）。我怀疑我不必要保留图。
有人可以让我知道pytorch的最佳做法吗？任何提示甚至简短的评论都将受到高度赞赏。
答案 0 :(得分：1)
我认为您正在尝试实现生成对抗网络（GAN），但是从代码中，我不理解也无法遵循您要实现的目标，因为GAN缺少一些功能作品。我可以看到有一个鉴别器网络模块DNetwork但缺少生成器网络模块。
如果猜测，当您说“损失函数两次”时，我假设您的意思是鉴别器网有一个损失函数，而发电机网有另一个损失函数。如果是这样，让我分享如何实现基本的GAN模型。
作为一个例子，让我们看一下这个Wasserstein GAN Jupyter notebook
我将跳过不太重要的部分，并在此处放大重要的部分：
首先，导入PyTorch库并进行设置
# Set up batch size, image size, and size of noise vector:
bs, sz, nz = 64, 64, 100 # nz is the size of the latent z vector for creating some random noise later
构建鉴别模块
class DCGAN_D(nn.Module):
def __init__(self):
... truncated, the usual neural nets stuffs, layers, etc ...
def forward(self, input):
... truncated, the usual neural nets stuffs, layers, etc ...
构建生成器模块
class DCGAN_G(nn.Module):
def __init__(self):
... truncated, the usual neural nets stuffs, layers, etc ...
def forward(self, input):
... truncated, the usual neural nets stuffs, layers, etc ...
将它们放在一起
netG = DCGAN_G().cuda()
netD = DCGAN_D().cuda()
Optimizer需要告知要优化的变量。模块自动跟踪其变量。
optimizerD = optim.RMSprop(netD.parameters(), lr = 1e-4)
optimizerG = optim.RMSprop(netG.parameters(), lr = 1e-4)
鉴别器的前进和后退步骤
在此，网络可以在反向传递期间计算梯度，具体取决于此函数的输入。因此，就我而言，我有3种损失；生成器损失，鉴别器实际图像丢失，鉴别器伪造图像丢失。对于3个不同的净通行证，我可以获得3次损失函数的梯度。
def step_D(input, init_grad):
# input can be from generator's generated image data or input image from dataset
err = netD(input)
err.backward(init_grad) # backward pass net to calculate gradient
return err # loss
控制可训练参数 [重要]
模型中的可训练参数是需要渐变的参数。
def make_trainable(net, val):
for p in net.parameters():
p.requires_grad = val # note, i.e, this is later set to False below in netG update in the train loop.
在TensorFlow中，该部分可以如下编码：
grad = tf.gradients(loss, X)
grad = tf.stop_gradient(grad)
因此，我认为这将回答您的第一个问题：“我用grad.detach_（）代替了tf.stop_gradient。这正确吗？”
火车循环
您可以在这里看到这三种不同的损失函数的调用方式。
def train(niter, first=True):
for epoch in range(niter):
# Make iterable from PyTorch DataLoader
data_iter = iter(dataloader)
i = 0
while i < n:
###########################
# (1) Update D network
###########################
make_trainable(netD, True)
# train the discriminator d_iters times
d_iters = 100
j = 0
while j < d_iters and i < n:
j += 1
i += 1
# clamp parameters to a cube
for p in netD.parameters():
p.data.clamp_(-0.01, 0.01)
data = next(data_iter)
##### train with real #####
real_cpu, _ = data
real_cpu = real_cpu.cuda()
real = Variable( data[0].cuda() )
netD.zero_grad()
# Real image discriminator loss
errD_real = step_D(real, one)
##### train with fake #####
fake = netG(create_noise(real.size()[0]))
input.data.resize_(real.size()).copy_(fake.data)
# Fake image discriminator loss
errD_fake = step_D(input, mone)
# Discriminator loss
errD = errD_real - errD_fake
optimizerD.step()
###########################
# (2) Update G network
###########################
make_trainable(netD, False)
netG.zero_grad()
# Generator loss
errG = step_D(netG(create_noise(bs)), one)
optimizerG.step()
print('[%d/%d][%d/%d] Loss_D: %f Loss_G: %f Loss_D_real: %f Loss_D_fake %f'
% (epoch, niter, i, n,
errD.data[0], errG.data[0], errD_real.data[0], errD_fake.data[0]))
“我收到“ RuntimeError：试图第二次向后浏览图形...”
PyTorch具有此行为；为了减少GPU内存的使用，在.backward()调用期间，所有不再需要的中间结果（如果您喜欢保存的激活信息等）都将被删除。因此，如果您尝试再次调用.backward()，则中间结果不存在，并且无法执行向后传递（并且会看到错误）。
这取决于您要尝试执行的操作。您可以致电.backward(retain_graph=True)进行向后传递，这不会删除中间结果，因此您可以再次致电.backward()。除了最后一个向后调用之外的所有选项都应具有retain_graph=True选项。
有人可以让我知道pytorch的最佳做法吗
从上面的PyTorch代码以及试图保持Python风格的PyTorch的工作方式中可以看到，您可以在那里了解PyTorch的最佳实践。
答案 1 :(得分：0)
如果您想使用高阶导数（即导数的导数），请查看backward的create_graph选项。
例如：
loss = get_loss()
loss.backward(create_graph=True)
loss_grad_penalty = loss + loss.grad
loss_grad_penalty.backward()