I am trying to implement a univariate time series model using vanilla RNNs. Following is the error I encounter:

```
/home/ggmu/anaconda3/envs/toothless/lib/python3.6/site-packages/torch/nn/modules/loss.py:443: UserWarning: Using a target size (torch.Size([5, 1, 1])) that is different to the input size (torch.Size([5, 10, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.
return F.mse_loss(input, target, reduction=self.reduction)
```

Input size = (90, 10)

output size = (90, 1)

Config:

```
batch_size = 5
input_size = 1
sequence_length = 10
hidden_size = 1
num_layer = 3
```

The RNN class:

```
class ModelRnn(nn.Module):
def __init__(self):
super(ModelRnn, self).__init__()
self.rnn = nn.RNN(input_size=input_size, hidden_size=hidden_size, batch_first=True, num_layers=num_layer)
def forward(self, x, hidden):
hidden = torch.zeros(num_layer, batch_size, hidden_size)
x = x.view(batch_size, sequence_length, input_size)
out, hidden = self.rnn(x, hidden)
return hidden, out
```

The data loader:

```
train_data = trainData(torch.FloatTensor(X_train), torch.FloatTensor(y_train))
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=False, num_workers=2)
model = ModelRnn()
print(model)
# ModelRnn(
# (rnn): RNN(1, 1, num_layers=3, batch_first=True)
# )
```

Optimizer:

```
optimizer=torch.optim.Adam(model.parameters(),lr=0.01)
criterion=nn.MSELoss()
```

Train loop:

```
for epoch in range(20):
for x_batch, y_batch in train_loader:
optimizer.zero_grad()
hidden, output = model(x_batch, hidden)
y_batch = y_batch.view(-1, 1, 1)
loss = criterion(output, y_batch)
loss.backward()
optimizer.step()
print(f"{epoch+1} epoch | loss = {loss}")
```

Following is the output + error:

```
1 epoch | loss = 9323.71484375
/home/ggmu/anaconda3/envs/toothless/lib/python3.6/site-packages/torch/nn/modules/loss.py:443: UserWarning: Using a target size (torch.Size([5, 1, 1])) that is different to the input size (torch.Size([5, 10, 1])). This will likely lead to incorrect results due to broadcasting. Please ensure they have the same size.
return F.mse_loss(input, target, reduction=self.reduction)
2 epoch | loss = 9261.478515625
3 epoch | loss = 9235.8857421875
4 epoch | loss = 9227.794921875
5 epoch | loss = 9224.625
6 epoch | loss = 9222.990234375
7 epoch | loss = 9221.98046875
8 epoch | loss = 9221.2890625
9 epoch | loss = 9220.783203125
10 epoch | loss = 9220.400390625
11 epoch | loss = 9220.099609375
12 epoch | loss = 9219.857421875
13 epoch | loss = 9219.6591796875
14 epoch | loss = 9219.4951171875
15 epoch | loss = 9219.3564453125
16 epoch | loss = 9219.23828125
17 epoch | loss = 9219.1357421875
18 epoch | loss = 9219.0478515625
19 epoch | loss = 9218.9697265625
20 epoch | loss = 9218.9013671875
```

I canâ€™t figure out the problem. The target size should be different from the input size. Because a sequence of 10 inputs give out 1 output. So, target size = (torch.Size([5, 1, 1])) should be different from input size = (torch.Size([5, 10, 1])).