Hi,
I am trying to implement a pix2pix gan,here is my architecture
generator
ij=True
class gen(nn.Module):
def __init__(self):
super(gen, self).__init__()
self.main=nn.Sequential(
nn.Conv2d(3,64,4,2,1),
nn.ReLU(ij),
nn.Conv2d(64,128,4,2,1),
nn.BatchNorm2d(128),
nn.ReLU(ij),
nn.Conv2d(128,256,4,2,1),
nn.BatchNorm2d(256),
nn.ReLU(ij),
nn.Conv2d(256,512,4,2,1),
nn.BatchNorm2d(512),
nn.ReLU(ij),
nn.Conv2d(512,1024,4),
nn.ConvTranspose2d(1024,512,4,1),
nn.BatchNorm2d(512),
nn.ReLU(ij),
nn.ConvTranspose2d(512,256,4,2,1),
nn.BatchNorm2d(256),
nn.ReLU(ij),
nn.ConvTranspose2d(256,128,4,2,1),
nn.BatchNorm2d(128),
nn.ReLU(ij),
nn.ConvTranspose2d(128,64,4,2,1),
nn.BatchNorm2d(64),
nn.ReLU(ij),
nn.ConvTranspose2d(64,3,4,2,1),
nn.Tanh()
)
def forward(self,inp):
return self.main(inp)
Differentiator
class diff(torch.nn.Module):
def __init__(self):
super(diff, self).__init__()
self.main=nn.Sequential(
nn.Conv2d(6,64,4,2,1),
nn.LeakyReLU(0.2,inplace=ij),
nn.Conv2d(64,128,4,2,1),
nn.BatchNorm2d(128),
nn.LeakyReLU(0.2,inplace=ij),
nn.Conv2d(128,256,4,2,1),
nn.BatchNorm2d(256),
nn.LeakyReLU(0.2,inplace=ij),
nn.Conv2d(256,512,4,2,1),
nn.BatchNorm2d(512),
nn.LeakyReLU(0.2,inplace=ij),
nn.Conv2d(512,256,4),
nn.LeakyReLU(0.2,inplace=ij),
nn.Conv2d(256,1,13),
nn.Sigmoid()
)
def forward(self,r1,r2):
r=torch.cat((r1,r2),0)
r=r.view(1,6,256,256)
return self.main(r)
Iteration loop
torch.autograd.set_detect_anomaly(True)
while iteration<10000:
gen_loss=0
dig_loss=0
gen_im=[]
actual_image=[]
i=0
########################################train generator##########################
for i in range(batch_size):
im=X[count].float()/255
im=im.view(3,256,256)
im=norm(im)
im=im.view(1,3,256,256)
pred=geng(im.float())
gen_im.append(pred)
score=random.uniform(0.85,1)
label=torch.tensor(score).view(1,1,1,1).to(device)
im_actual=Y[count].float()
im_actual=norm(im_actual.view(3,256,256)).view(1,3,256,256)
actual_image.append(im_actual)
class_predicted=dig(pred,im_actual)
loss_gen=loss_fn(class_predicted,label)
gen_loss=gen_loss+loss_gen
count=count+1
gen_loss=gen_loss/batch_size
gen_loss.backward(retain_graph=True)
og.step()
geng.zero_grad()
dig.zero_grad()
#########################################train discriminator######################
for i in range(batch_size):
score_fake=random.uniform(0.0,0.15)
score_real=random.uniform(0.85,1.00)
label_fake=torch.tensor(score_fake).view(1,1,1,1).to(device)
label_real=torch.tensor(score_real).view(1,1,1,1).to(device)
loss_real=loss_fn(dig(actual_image[i],actual_image[i]),label_real)
loss_fake=loss_fn(dig(gen_im[i],actual_image[i]),label_fake)
dig_loss=dig_loss+(loss_real+loss_fake)
di_loss=dig_loss/batch_size
di_loss.backward()
od.step()
this is the error that i encounter.
RuntimeError Traceback (most recent call last)
<ipython-input-72-85806ea5cb74> in <module>()
49 dig_loss=dig_loss+(loss_real+loss_fake)
50 di_loss=dig_loss/batch_size
---> 51 di_loss.backward()
52 od.step()
53
1 frames
/usr/local/lib/python3.6/dist-packages/torch/autograd/__init__.py in backward(tensors, grad_tensors, retain_graph, create_graph, grad_variables)
98 Variable._execution_engine.run_backward(
99 tensors, grad_tensors, retain_graph, create_graph,
--> 100 allow_unreachable=True) # allow_unreachable flag
101
102
RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.cuda.FloatTensor [64, 3, 4, 4]] is at version 2; expected version 1 instead. Hint: the backtrace further above shows the operation that failed to compute its gradient. The variable in question was changed in there or anywhere later. Good luck!
Please help me find the inplace operation.I know that the fault is not in ReLU’s inplace as i have used relu inplace before and did not encounter this error.