Hi, Can any one please help me to resolve this issue.
i have created a simple CRNN-model(an encoder decoder) which is having trouble in backpropagaition.
class OCR_EncoderDecoder(nn.Module):
def __init__(self,hidden_size1,hidden_size2,output_size,verbose=False):
super(OCR_EncoderDecoder, self).__init__()
self.hidden_size1 = hidden_size1
self.hidden_size2 = hidden_size2
self.output_size = output_size
self.encoder_cnn_cell = nn.Sequential(
nn.Conv2d(3,28,3,padding=(0,0), stride=1),#----> layer-1
nn.BatchNorm2d(28),
nn.ReLU(),
nn.MaxPool2d(2,2),
nn.Conv2d(28,32,3,padding=(0,0)),#-----> Layer-2
nn.BatchNorm2d(32),
nn.ReLU(),
nn.MaxPool2d(2,2),
nn.Conv2d(32,64,3,padding=(0,0)),#-----> Layer-3
nn.Conv2d(64,128,3,padding=(1,1)),#-----> Layer-4
nn.BatchNorm2d(128),
nn.ReLU(),
nn.MaxPool2d(2,2),
nn.Conv2d(128,256,3,padding=(1,1)),#-----> Layer-5
nn.BatchNorm2d(256),
nn.ReLU()
)
self.Conv_Linear = nn.Sequential(
nn.Linear(1536,self.hidden_size1))
self.decoder_rnn_cell1 = nn.GRU(self.hidden_size1,self.hidden_size2)
self.decoder_rnn_cell2 = nn.GRU(self.hidden_size2,self.output_size)
self.Rnn_Linear = nn.Sequential(
nn.Linear(self.output_size, self.output_size),
nn.LogSoftmax(2))
#self.softmax = nn.LogSoftmax(dim=2)
self.verbose = verbose
def forward(self,batch):
# encoder
batch = self.encoder_cnn_cell(batch)
batch = batch.permute(0,3,2,1)
# Decoder
batch = batch.reshape(batch.size(0),batch.size(1),-1)
batch = self.Conv_Linear(batch)
batch,_ = self.decoder_rnn_cell1(batch)
batch,_ = self.decoder_rnn_cell2(batch)
batch = self.Rnn_Linear(batch)
#batch = self.softmax(batch)
return batch
U = OCR_EncoderDecoder(128,256,129,False)
B = U(u)
B.shape #torch.Size([2, 26, 129])
LOSS = {}
Loss = 0
for k in range(25):
opt.zero_grad()
for i in range(B.size(0)):
input_ = B[i].view(B.size(1),1,B.size(2))
op = gt_rep(v[i],hindi_alpha2index)
op = op.view(1,-1)
input_length = torch.full(size=(1,), fill_value= input_.size(0), dtype=torch.long)
target_length = torch.randint(low=1, high=op.size(1), size=(1,), dtype=torch.long)
print(input_.shape)
print(op.shape)
print(input_length,target_length)
loss = loss_fn(input_,op,input_length,target_length)
loss.backward(retain_graph=True)
Loss += loss
print(k)
LOSS[k] = Loss/2
opt.step()
i have used a CTC loss and trying to backpropagate, however says this error :
RuntimeError: one of the variables needed for gradient computation has been modified by an inplace operation: [torch.FloatTensor [129, 129]], 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).
Kindly help in solving this issue.