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