```
class LSTMPricePredictor(nn.Module):
def __init__(self, input_size, hidden_size, output_size, num_layers):
super().__init__()
self.input_dim = input_size
self.hidden_dim = hidden_size
self.num_layers = num_layers
self.init_hidden()
self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, batch_first=True)
self.hidden_to_output = nn.Linear(hidden_size, output_size)
def init_hidden(self):
self.hidden = (torch.zeros((self.num_layers, 1, self.hidden_dim), requires_grad=True), torch.zeros((self.num_layers, 1, self.hidden_dim)))
def forward(self, inputs):
x, (hx, cx) = inputs
lstm_out, (hx, cx) = self.lstm(x, (hx, cx))
#out = self.hidden_to_output(lstm_out.view(-1, self.hidden_dim))
out = self.hidden_to_output(lstm_out)
return out, (hx, cx)
class StatefullLSTMPricePredictor(LSTMPricePredictor):
def forward(self, input_batches):
linear_layers_results = []
self.hidden[0].detach_()
for i, input_batch in enumerate(input_batches):
lstm_out, self.hidden = self.lstm(input_batch.unsqueeze(0), self.hidden)
linear_layers_results.append(self.hidden_to_output(lstm_out[:, -1:, :]))
return torch.cat(linear_layers_results, dim=0)
model = StatefullLSTMPricePredictor(4, HIDDEN_SIZE, 4, 1)
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters())
for i in range(3, len(features), 3):
criterion.zero_grad()
out = model(features[:i])
loss = criterion(out, labels[:i])
# loss.backward() if i == 3 else loss.backward(retain_graph=True)
loss.backward()
optimizer.step()
```

Evaluating these code to train stateful LSTM cause following error:

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.

Can use please explain what is wrong?