2022-03-01 12:55:57

跑一个GAN DEMO , 运行时出错。
出错代码：

RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [128, 1]], which is output 0 of TBackward, is at version 2; expected version 1 instead. Hint: enable anomaly detection to find the operation that failed to compute its gradient, with torch.autograd.set_detect_anomaly(True).

原因是：
错误来源于 PYTORCH的版本不同（我的运行版本是1.8.1, 源代码出自1.4.1版本）， 内置的BACKWARD的流程发生了变化，

原始代码：

# 使用 GAN 生成一个类似二次曲线
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
# torch.manual_seed(1)       # reproducible
# np.random.seed(1)
# Hyper Parameters
BATCH_SIZE = 64
LR_G = 0.0001       # learning rate for generator
LR_D = 0.0001       # learning rate for discriminator
N_IDEAS = 5         # think of this as number of ideas for generating an art work(Generator)
ART_COMPONENTS = 15 # it could be total point G can drew in the canvas
PAINT_POINTS = np.vstack([np.linspace(-1, 1, ART_COMPONENTS) for _ in range(BATCH_SIZE)])
# show our beautiful painting range
plt.plot(PAINT_POINTS[0], np.sin(PAINT_POINTS[0] * np.pi), c='#74BCFF', lw=3, label='standard curve')
plt.legend(loc='best')
plt.show()
def artist_works():    # painting from the famous artist (real target)
    #a = np.random.uniform(1, 2, size=BATCH_SIZE)[:, np.newaxis]
    r = 0.02 * np.random.randn(1, ART_COMPONENTS)
    paintings = np.sin(PAINT_POINTS * np.pi) + r
    paintings = torch.from_numpy(paintings).float()
    return paintings
r = 0.02 * np.random.randn(1, ART_COMPONENTS)
paintings = np.sin(PAINT_POINTS * np.pi) + r
plt.plot(PAINT_POINTS[0],paintings[0])
plt.show()
G = nn.Sequential(                  # Generator
    nn.Linear(N_IDEAS, 128),        # random ideas (could from normal distribution)
    nn.ReLU(),
    nn.Linear(128, ART_COMPONENTS), # making a painting from these random ideas
D = nn.Sequential(                  # Discriminator
    nn.Linear(ART_COMPONENTS, 128), # receive art work either from the famous artist or a newbie like G
    nn.ReLU(),
    nn.Linear(128, 1),
    nn.Sigmoid(),                   # tell the probability that the art work is made by artist
opt_D = torch.optim.Adam(D.parameters(), lr=LR_D)
opt_G = torch.optim.Adam(G.parameters(), lr=LR_G)
plt.ion()    # something about continuous plotting
D_loss_history = []
G_loss_history = []
for step in range(10000):
    artist_paintings = artist_works()          # real painting from artist , shape of [64,15]
    G_ideas = torch.randn(BATCH_SIZE, N_IDEAS) # random ideas, shape of [64, 5]
    G_paintings = G(G_ideas)                   # fake painting from G (random ideas),  G_paintings.shape= [64,15])
    prob_artist0 = D(artist_paintings)         # D try to increase this prob, prob_artist0.shape =[64,1]
    prob_artist1 = D(G_paintings)              # D try to reduce this prob, prob_artist1.shape =[64,1]
    D_loss = - torch.mean(torch.log(prob_artist0) + torch.log(1. - prob_artist1))
    G_loss = torch.mean(torch.log(1. - prob_artist1))
    D_loss_history.append(D_loss)
    G_loss_history.append(G_loss)
    opt_D.zero_grad()
    D_loss.backward(retain_graph=True)    # reusing computational graph
    opt_D.step()
    opt_G.zero_grad()
    G_loss.backward()
    opt_G.step()
    if step % 50 == 0:  # plotting
        plt.cla()
        plt.plot(PAINT_POINTS[0], G_paintings.data.numpy()[0], c='#4AD631', lw=3, label='Generated painting',)
        plt.plot(PAINT_POINTS[0], np.sin(PAINT_POINTS[0] * np.pi), c='#74BCFF', lw=3, label='standard curve')
        plt.text(-1, 0.75, 'D accuracy=%.2f (0.5 for D to converge)' % prob_artist0.data.numpy().mean(), fontdict={'size': 8})
        plt.text(-1, 0.5, 'D score= %.2f (-1.38 for G to converge)' % -D_loss.data.numpy(), fontdict={'size': 8})
        plt.ylim((-1, 1));plt.legend(loc='lower right', fontsize=10);plt.draw();plt.pause(0.01)
plt.ioff()
plt.show()
修改后的代码：
 
# 使用 GAN 生成一个类似二次曲线
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
# torch.manual_seed(1)       # reproducible
# np.random.seed(1)
# Hyper Parameters
BATCH_SIZE = 64
LR_G = 0.0001       # learning rate for generator
LR_D = 0.0001       # learning rate for discriminator
N_IDEAS = 5         # think of this as number of ideas for generating an art work(Generator)
ART_COMPONENTS = 15 # it could be total point G can drew in the canvas
PAINT_POINTS = np.vstack([np.linspace(-1, 1, ART_COMPONENTS) for _ in range(BATCH_SIZE)])
# show our beautiful painting range
plt.plot(PAINT_POINTS[0], np.sin(PAINT_POINTS[0] * np.pi), c='#74BCFF', lw=3, label='standard curve')
plt.legend(loc='best')
plt.show()
def artist_works():    # painting from the famous artist (real target)
    #a = np.random.uniform(1, 2, size=BATCH_SIZE)[:, np.newaxis]
    r = 0.02 * np.random.randn(1, ART_COMPONENTS)
    paintings = np.sin(PAINT_POINTS * np.pi) + r
    paintings = torch.from_numpy(paintings).float()
    return paintings
r = 0.02 * np.random.randn(1, ART_COMPONENTS)
paintings = np.sin(PAINT_POINTS * np.pi) + r
plt.plot(PAINT_POINTS[0],paintings[0])
plt.show()
G = nn.Sequential(                  # Generator
    nn.Linear(N_IDEAS, 128),        # random ideas (could from normal distribution)
    nn.ReLU(),
    nn.Linear(128, ART_COMPONENTS), # making a painting from these random ideas
D = nn.Sequential(                  # Discriminator
    nn.Linear(ART_COMPONENTS, 128), # receive art work either from the famous artist or a newbie like G
    nn.ReLU(),
    nn.Linear(128, 1),
    nn.Sigmoid(),                   # tell the probability that the art work is made by artist
opt_D = torch.optim.Adam(D.parameters(), lr=LR_D)
opt_G = torch.optim.Adam(G.parameters(), lr=LR_G)
plt.ion()    # something about continuous plotting
D_loss_history = []
G_loss_history = []
for step in range(10000):
    artist_paintings = artist_works()          # real painting from artist , shape of [64,15]
    G_ideas = torch.randn(BATCH_SIZE, N_IDEAS) # random ideas, shape of [64, 5]
    G_paintings = G(G_ideas)                   # fake painting from G (random ideas),  G_paintings.shape= [64,15])
    prob_artist1 = D(G_paintings)              # D try to reduce this prob, prob_artist1.shape =[64,1]
    G_loss = torch.mean(torch.log(1. - prob_artist1))
    opt_G.zero_grad()
    G_loss.backward()
    opt_G.step()
    prob_artist0 = D(artist_paintings)         # D try to increase this prob, prob_artist0.shape =[64,1]
    # detach here to make sure we don't backprop in G that was already changed.
    prob_artist1 = D(G_paintings.detach())  # D try to reduce this prob
    D_loss_history.append(D_loss)
    G_loss_history.append(G_loss)
    D_loss = - torch.mean(torch.log(prob_artist0) + torch.log(1. - prob_artist1))
    opt_D.zero_grad()
    D_loss.backward(retain_graph=True)    # reusing computational graph
    opt_D.step()
    if step % 50 == 0:  # plotting
        plt.cla()
        plt.plot(PAINT_POINTS[0], G_paintings.data.numpy()[0], c='#4AD631', lw=3, label='Generated painting',)
        plt.plot(PAINT_POINTS[0], np.sin(PAINT_POINTS[0] * np.pi), c='#74BCFF', lw=3, label='standard curve')
        plt.text(-1, 0.75, 'D accuracy=%.2f (0.5 for D to converge)' % prob_artist0.data.numpy().mean(), fontdict={'size': 8})
        plt.text(-1, 0.5, 'D score= %.2f (-1.38 for G to converge)' % -D_loss.data.numpy(), fontdict={'size': 8})
        plt.ylim((-1, 1));plt.legend(loc='lower right', fontsize=10);plt.draw();plt.pause(0.01)
plt.ioff()
plt.show()
运行结果：
 

 。。。。。。
 
　　 MySQL 5.7.5和up实现了对功能依赖的检测。如果启用了only_full_group_by SQL模式(在默认情况下是这样)，那么MySQL就会拒绝选择列表、条件或顺序列表引用的查询，这些查询将引用组中未命名的非聚合列，而不是在功能上依赖于它们。(在5.7.5之前，MySQL没有检测到功能依赖项，only_full_group_by在默认情况下是不启用的。关于前5.7.5行为的描述，请参阅MySQL 5.6参考手册。)
　　执行以下个命令，可以查看 sql_mode 的内容：　　
mysql> SHOW SESSION VARIABLES;
mysql> SHOW GL
                                    解决GAN训练过程中的报错：one of the variables needed for gradient computation has been modified by an inplace operation
                                    报错：one of the variables needed for gradient computation has been modified by an inplace operation
                                    这个问题多半是因为引用传递参数引起的，解决办法一是修改代码不使用引用传递；另一个办法是修改php配置文件，修改error_reporting 其值改为error_reporting = E_ALL& ~E_NOTICE。或者修改函数中的引用方式即可。
ps：修改配置文件时，最好是复制一行，注掉，然后再改，如果需要随时切回。
ECShop出现Strict Standards: Only variables should be passed by reference in的解决方法
今天安装ecshop的时候最上面出现了一个错误提示：Strict Standards: Only variables
                                    【就看这一篇就行】RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.cuda.FloatTensor [256]] is at version 4; expected version 3 instead. Hint: enable anomaly detection to find the operation that fai
                                    写完了训练的代码，运行了以后发现了这么一个错：
RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [544, 768]], which is output 0 of ViewBackward, is at version 1; expected version 0 instead. 
Hint: en
                                    今天跑网络在进行loss.backward()的时候，出现了如下错误：
one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [2, 64]], which is output 0 of ViewBackward, is at version 21;
expected version 20 instead. Hint: enabl
                                    GAN介绍
理解GAN的直观方法是从博弈论的角度来理解它。GAN由两个参与者组成，即一个生成器和一个判别器，它们都试图击败对方。生成备从分巾中狄取一些随机噪声，并试图从中生成一些类似于输出的分布。生成器总是试图创建与真实分布没有区别的分布。也就是说，伪造的输出看起来应该是真实的图像。 然而，如果没有显式训练或标注，那么生成器将无法判别真实的图像，并且其唯一的来源就是随机浮点数的张量。
之后，GAN将在博弈中引入另一个参与者，即判别器。判别器仅负责通知生成器其生成的输出看起来不像真实图像，以便生成器更改其生成
                                    对于.add_()方法，是直接在tensor上进行修改的，可以把x.add_(y)改成x = x + y。即问题中所描述的inplace operation的问题，这种问题常常是某些变量还没有保存就已经被替换掉了，一般在报错的过程中会显示错误变量的shape,这时最好是看一下代码中关于这个shape的所有变量，加上clone(),试试！我就是这个问题，试完我的问题就解决了。最近跑代码遇到了这样的一个问题，在网上找了很多方法都没有很好的解决，今天就在这个博客里面将所有的解决办法整理记录一下。
                                    首先说明，按照我目前的查询，这可能是全网唯一公开的正确解决方法，所以一定要看下去
1、错误发生情景
在github和百度上搜索gan示例代码的时候，通常会得到下面这种代码：先更新辨别器，再更新生成器。
            netD.zero_grad()
            #optimizerD.step()
            real_out = netD(real_img).mean()
            fake_out = netD(fake_img).mean()