Hello, I’m implementing an LSTM to predict today’s stock price using the past 10 days’ close price.
Therefore, my input is [batch_size, sequence_len = 10, input_size = 1] since there is only one feature every day.
Then I set batch_size = 50 and implement a train_loader with TensorDataset and DataLoader.
My LSTM model is defined as
class LSTM(nn.Module):
    def __init__(self, input_dim, hidden_dim, batch_size, output_dim, num_layers, dropout = 0.1):
        super(LSTM, self).__init__()
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.batch_size = batch_size
        self.num_layers = num_layers
        self.dropout = dropout
        self.output_dim = output_dim

        # Define the LSTM layer
        self.lstm = nn.LSTM(input_size = input_dim, hidden_size = hidden_dim, num_layers = num_layers, dropout = dropout, batch_first = True)
        
        # Define the output layer, fully connected
        self.linear = nn.Linear(hidden_dim, output_dim)
              
    def init_hidden(self):
        # initialise our hidden state
        return (torch.zeros(self.num_layers, self.batch_size, self.hidden_dim),
                torch.zeros(self.num_layers, self.batch_size, self.hidden_dim))
 
    def forward(self, x):
        # Forward pass through LSTM layer
        # shape of out: [input_size, batch_size, hidden_dim]
        # shape of self.hidden: (a, b), where a and b both have shape (num_layers, batch_size, hidden_dim).
        
        out, self.hidden = self.lstm(x, self.init_hidden)
        y_pred = self.linear(out[:, -1, :]) 
        return y_pred

And when I train the model,
INPUT_SIZE = 1 # number of features
HIDDEN_SIZE = 64
NUM_LAYERS = 3
OUTPUT_SIZE = 1

learning_rate = 0.001
num_epochs = 150 
model = LSTM(INPUT_SIZE, HIDDEN_SIZE, batch_size, OUTPUT_SIZE, NUM_LAYERS)
loss_fn = torch.nn.MSELoss()
optimiser = torch.optim.Adam(model.parameters(), lr = learning_rate)
model.hidden = model.init_hidden()
model.train()  
for local_batch, local_labels in train_loader:
    # Transfer to GPU
    local_batch = local_batch.float().to(device)
    local_labels = local_labels.float().to(device)

    print(local_batch.shape) # torch.Size([50, 10, 1])
    print(local_labels.shape) # torch.Size([50, 1])

    # Forward pass
    y_pred = model(local_batch)
    loss = loss_fn(y_pred, local_labels)

    optimiser.zero_grad()

    # Backward pass
    loss.backward()

    # Update parameters
    optimiser.step()


I got this error in y_pred = model(local_batch)  at /usr/local/lib/python3.6/dist-packages/torch/nn/modules/rnn.py in check_forward_args(self, input, hidden, batch_sizes):
-> 522         self.check_hidden_size(hidden[0], expected_hidden_size,
    523                                'Expected hidden[0] size {}, got {}')

TypeError: ‘method’ object is not subscriptable
I’m new to LSTM, any hints are appreciable!