I’m getting the following error:
RuntimeError: input must have 3 dimensions, got 2
I have a single feature column that I am trying to feed into a GRU neural net.
Below are my data loader and neural net. I have also included the output of my data loader when I feed in the first 50 data points.
What am I doing wrong?
def batch_data(feature1, sequence_length, batch_size):
“”"
Batch the neural network data using DataLoader
:param feature1: the single feature column
:param sequence_length: The sequence length of each batch
:param batch_size: The size of each batch; the number of sequences in a batch
:return: DataLoader with batched data
“”"
# total number of batches we can make
n_batches = len(feature1)//batch_size

# Keep only enough characters to make full batches
feature1= feature1[:n_batches * batch_size]

y_len = len(feature1) - sequence_length

x, y = [], []
for idx in range(0, y_len):
    idx_end = sequence_length + idx
    x_batch = feature1[idx:idx_end]
    x.append(x_batch)
    # only making predictions after the last item in the batch
    batch_y = feature1[idx_end]    
    y.append(batch_y)    

# create tensor datasets
data = TensorDataset(torch.from_numpy(np.asarray(x)), torch.from_numpy(np.asarray(y)))

data_loader = DataLoader(data, shuffle=False, batch_size=batch_size)

# return a dataloader
return data_loader

# test dataloader on subset of actual data

test_text = data_subset_b[0:50]
t_loader = batch_data(test_text, sequence_length=5, batch_size=10)
 
data_iter = iter(t_loader)
sample_x, sample_y = data_iter.next()
 
print(sample_x.shape)
print(sample_x)
print()
print(sample_y.shape)
print(sample_y)

When I pass in the a batch of data into the data loader, I get the following  …
torch.Size([10, 5])
tensor([[ 0.0045,  0.0040, -0.0008,  0.0005, -0.0012],
[ 0.0040, -0.0008,  0.0005, -0.0012,  0.0000],
[-0.0008,  0.0005, -0.0012,  0.0000, -0.0015],
[ 0.0005, -0.0012,  0.0000, -0.0015,  0.0008],
[-0.0012,  0.0000, -0.0015,  0.0008,  0.0000],
[ 0.0000, -0.0015,  0.0008,  0.0000,  0.0000],
[-0.0015,  0.0008,  0.0000,  0.0000, -0.0008],
[ 0.0008,  0.0000,  0.0000, -0.0008, -0.0039],
[ 0.0000,  0.0000, -0.0008, -0.0039, -0.0026],
[ 0.0000, -0.0008, -0.0039, -0.0026, -0.0082]], dtype=torch.float64)
torch.Size([10])
tensor([ 0.0000, -0.0015,  0.0008,  0.0000,  0.0000, -0.0008, -0.0039, -0.0026,
-0.0082,  0.0078], dtype=torch.float64)
Here is my neural net architecture:
class GRU(nn.Module):
def __init__(self, input_dim, output_dim, n_hidden, n_layers, dropout=0.25, lr=0.001):
    super().__init__()
    
    # set class variables
    self.output_dim = output_dim
    self.n_layers = n_layers
    self.n_hidden = n_hidden
    
    # define model layers
    
    # define gru layer
    self.gru = nn.GRU(input_dim, n_hidden, n_layers, dropout=dropout, batch_first=True)
    
    # define a dropout layer
    self.dropout = nn.Dropout(dropout)
    
    # define the final, fully-connected output layer
    self.fc = nn.Linear(n_hidden, output_dim)   


def forward(self, nn_input, hidden):
    ''' Forward pass through the network. 
        These inputs are x, and the hidden/cell state `hidden`. '''
    
    # batch_size equals the input's first dimension
    batch_size = nn_input.size(0)
    
    # Get the outputs and the new hidden state from the lstm
    r_output, hidden = self.gru(nn_input, hidden)
    
    # pass through a dropout layer
    out = self.dropout(r_output)
    
    # Stack up LSTM outputs using view
    # you may need to use contiguous to reshape the output
    out = out.contiguous().view(-1, self.n_hidden)
    
    # put nn_input through the fully-connected layer
    out = self.fc(out)

    # reshape into (batch_size, seq_length, output_size)
    out = out.view(batch_size, -1, self.output_dim)
    
    # get last batch
    out = out[:, -1]
    
    # return the final output and the hidden state
    return out, hidden


def init_hidden(self, batch_size):
    ''' Initializes hidden state '''
    # Create two new tensors with sizes n_layers x batch_size x n_hidden,
    # initialized to zero, for hidden state and cell state of LSTM
    weight = next(self.parameters()).data
    
    if (train_on_gpu):
        hidden = (weight.new(self.n_layers, batch_size, self.n_hidden).zero_().cuda(),
                  weight.new(self.n_layers, batch_size, self.n_hidden).zero_().cuda())
    else:
        hidden = (weight.new(self.n_layers, batch_size, self.n_hidden).zero_(),
                  weight.new(self.n_layers, batch_size, self.n_hidden).zero_())
    
    return hidden