LSTM Autoencoders is throwing an error during the backward() function. Below is the model.
class Encoder(nn.Module):
def init(self,input_size,hidden_size):
super(Encoder,self).init()
    self.input_size = input_size
    self.hidden_size = hidden_size
    self.lstm = nn.LSTM(input_size = input_size,
                        hidden_size = hidden_size,
                        num_layers = 1,batch_first=True)
    
def forward(self,x):
    output , (h,c) = self.lstm(x)
    hidden_layer = h[-1,:,:]
    return hidden_layer     

class Decoder(nn.Module):
def init(self,seq_len,input_size,output_size):
super(Decoder,self).init()
    self.seq_len = seq_len
    self.input_size = input_size
    self.layer1 = (input_size * 2)
    self.output_size = output_size
    self.lstm = nn.LSTM(input_size = input_size,
                       hidden_size = self.layer1,
                       num_layers = 1,
                       batch_first = True)
    self.fc = nn.Linear(self.layer1, output_size)
        
    
def forward(self,x):
    x = x.unsqueeze(1).repeat(1,self.seq_len,1)
    x,(h,c) = self.lstm(x)
    x = x.reshape((-1, self.seq_len, self.layer1))
    out = self.fc(x)
    return out

#AutoEncoders in place
class LSTM_AE(nn.Module):
def init(self, seq_len, input_size, hidden_size):
super(LSTM_AE,self).init()
    self.seq_len = seq_len
    self.input_size = input_size
    self.hidden_size = hidden_size

    self.encoder = Encoder(self.input_size, self.hidden_size)
    self.decoder = Decoder(self.seq_len, self.hidden_size, self.input_size)
    

def forward(self, x):
    encoded = self.encoder(x)
    decoded = self.decoder(encoded)
    return decoded

#Model
model = LSTM_AE(seq_len=max_len,input_size=final_embed[events[0]].size(2),hidden_size=32)
#Loss
loss_fn = nn.L1Loss(reduction=‘sum’)
#Optimizer
optimizer = torch.optim.Adam(model.parameters(),lr=0.001)
n_epochs = 1 # or whatever
losses = []
for epoch in range(n_epochs):
for batch_idx, (a,b,c,d) in enumerate(loader):
    #a = a.clone().detach().requires_grad_(True)

    # in case you wanted a semi-full example
    decoded = model.forward(a)
    print(decoded.size())
    
    loss = loss_fn(decoded,a)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if batch_idx%10 == 0:
        losses.append(loss)
        print("epoch {}.\tbatch {}.\tloss : {}".format(epoch,batch_idx,loss))

This is throwing the error as
RuntimeError: Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). Saved intermediate values of the graph are freed when you call .backward() or autograd.grad(). Specify retain_graph=True if you need to backward through the graph a second time or if you need to access saved tensors after calling backward.
I am able to run this by adding the requires_grad on the train dataset  i.e. a in the above forward call but unable to understand the problem here as I generally don’t do that while running the other models on torch