Hello, I am new to pytorch and have some questions regarding how to create a many-to-many lstm model. I am trying to predict the next number (x_t+1) in a sequence given an input sequence of integers like
[0, 1, 2, 3, 2, 1] - data from x_t-5 to x_t.
So example [0, 1, 2, 3, 2, 1] -> lstm model -> should give [1, 2, 3, 2, 1, 0]
So when I run the model with input sequence from x_t-5 to x_t, i expect the model to train and give an output sequence from x_t-4 to x_t+1.
Can anybody give me an example or fix my code? As i couldn’t find anywhere online with a simple example for such model that i am creating.
Or tell me what is wrong with my code? or my understanding of pytorch lstm?
May I also ask if what exactly should be the hidden_size for my model?
Below is my source code which does not run.
Any help will be greatly appreciated!
import torch
from torch.autograd import Variable
import torch.nn as nn

torch.manual_seed(1)

x_train = [ [[0], [1], [2], [3], [2], [1]],
             [[1], [2], [3], [2], [1], [0]],
             [[2], [3], [2], [1], [0], [1]],
             [[3], [2], [1], [0], [1], [2]],
             [[2], [1], [0], [1], [2], [3]] ]

y_train = [[[1], [2], [3], [2], [1], [0]],
             [[2], [3], [2], [1], [0], [1]],
             [[3], [2], [1], [0], [1], [2]],
             [[2], [1], [0], [1], [2], [3]],
             [[1], [0], [1], [2], [3], [2]]]

inputs = Variable(torch.Tensor(x_train))
labels = Variable(torch.Tensor(y_train))

input_size =  1
hidden_size = 32
batch_size = 5
sequence_length = 6
num_layers = 1

class LSTM(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, sequence_length):
        super(LSTM, self).__init__()

        self.num_layers = num_layers
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.sequence_length = sequence_length

        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, batch_first=True)

    def forward(self, x):
        # (num_layers * num_directions, batch, hidden_size)
        h_0 = (Variable(torch.zeros(self.num_layers, x.size(0), self.hidden_size)) for _ in range(self.hidden_size))
        # Reshape input
        x.view(x.size(0), self.sequence_length, self.input_size)

        out, _ = self.lstm(x, h_0)

        return out

lstm = LSTM(input_size, hidden_size, num_layers, sequence_length)
print (lstm)

criterion = torch.nn.MSELoss()
optimizer = torch.optim.Adam(lstm.parameters(), lr=0.1)

# Train the model
for epoch in range(100):
    loss = 0
    outputs = lstm(inputs)
    optimizer.zero_grad()
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()
    print ("epoch : %d, loss: %1.3f" %(epoch+1, loss.data[0]))

print ("Learning finished!")