Hello!
I have created dataset for 4 diff functions. My dataset is one-hot-encoded. Basically just 40 data elements, each being a one-hot-encoded string of 11 characters. There are total of 31 mappings.
So my dataset looks like tensor of (40,11,31)
My output is a label, with one one-hot-encoded letter. e.g. h,f
so label tensor is of the size (40,1,31)
My code looks like this
Error occurs on line
loss = criterion(outputs, labels)
 ```python
import torch
import torch.nn as nn
from torch.autograd import Variable


###################### define parameters for RNN #############

inputs = Variable(torch.Tensor(input_tensors_one_hot))
labels = Variable(torch.LongTensor(tensor_of_labels))

# print(f'im inputs size {inputs.size()}' )
print(f'im labels size {labels}' )


num_classes = 31
input_size = 31  # one-hot size
hidden_size = 31  # output from the LSTM. 31 to directly predict one-hot
batch_size = 1   # one string
sequence_length = 11  # string length == 11
num_layers = 1  # one-layer rnn
# print(inputs[0])

################ Define RNN #################

class RNN(nn.Module):

    def __init__(self, num_classes, input_size, hidden_size, num_layers):
        super(RNN, self).__init__()

        self.num_classes = num_classes
        self.num_layers = num_layers
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.sequence_length = sequence_length
        self.rnn = nn.RNN(input_size=31, hidden_size=31, batch_first=True)


    def forward(self, x):
        # Initialize hidden and cell states
        # (num_layers * num_directions, batch, hidden_size) for batch_first=True
        h_0 = Variable(torch.zeros(
            self.num_layers, x.size(0), self.hidden_size))

        # Reshape input
        x.view(x.size(0), self.sequence_length, self.input_size)    
# Propagate input through RNN
        # Input: (batch, seq_len, input_size)
        # h_0: (num_layers * num_directions, batch, hidden_size)

        out, _ = self.rnn(x, h_0)
        print(f'im hidden size shape {out.size()}')

        # dense_outputs = self.fc(out)
        # print(f'im dense outputs {dense_outputs}')
        return out.reshape(-1, num_classes)
        # return out.view(-1, num_classes)


# Instantiate RNN model
rnn = RNN(num_classes, input_size, hidden_size, num_layers)
print(rnn)

# Set loss and optimizer function
# CrossEntropyLoss = LogSoftmax + NLLLoss
criterion = torch.nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(rnn.parameters(), lr=0.1)

# Train the model
for epoch in range(100):
    outputs = rnn(inputs)
    print('Im output size ', outputs.size())
    optimizer.zero_grad()
    print('Im label size ', labels.size())
    loss = criterion(outputs, labels)  
    loss.backward()
    optimizer.step()
    _, idx = outputs.max(1)
    idx = idx.data.numpy()
    # result_str = [idx2char[c] for c in idx.squeeze()]
    # print("epoch: %d, loss: %1.3f" % (epoch + 1, loss.data[0]))
    # print("Predicted string: ", ''.join(result_str))
    print("Predicted string: ", ''.join(idx))

print("Learning finished!")