```
class CharLevelLanguageModel(torch.nn.Module):
def __init__(self,vocab_size,emb_dim,hidden_dim,batch_size):
super(CharLevelLanguageModel,self).__init__()
self.embedddings = torch.nn.Embedding(vocab_size,emb_dim,padding_idx=0)
self.lstm = torch.nn.LSTM(emb_dim,hidden_dim,1,batch_first=True)
self.linear = torch.nn.Linear(hidden_dim,vocab_size)
self.batch_size = batch_size
self.hidden_dim = hidden_dim
self.hidden_state = self.init_hidden()
def init_hidden(self):
return (Variable(torch.zeros(1,self.batch_size,self.hidden_dim)),Variable(torch.zeros(1,self.batch_size,self.hidden_dim)))
def forward(self,x):
embeds = self.embedddings(x)
output,self.hidden_state = self.lstm(embeds,self.hidden_state)
return F.log_softmax(self.linear(F.tanh(output[:,-1,:])))
train = data_utils.TensorDataset(torch.LongTensor(dataX),torch.LongTensor(dataY))
train_loader = data_utils.DataLoader(train,batch_size=100,drop_last=True)
model = CharLevelLanguageModel(len(char_to_id)+1,100,50,100)
criterion = torch.nn.NLLLoss()
optimizer = torch.optim.Adam(model.parameters())
losses = []
for i in range(3):
total_loss = torch.FloatTensor([0])
for batch_idx,train in enumerate(train_loader):
model.hidden_state = model.init_hidden()
x,y = Variable(train[0]),Variable(train[1])
y_pred = model(x)
#print()
loss = criterion(y_pred,y)
total_loss+=loss.data
loss.backward()
optimizer.zero_grad()
optimizer.step()
losses.append(total_loss)
```

Above is the training code.

```
model.eval()
testX = dataX[0:2]
testVar = Variable(torch.LongTensor(testX))
```

The above code throws inconsistent size error.

But if I run the below code:

```
testX = dataX[0]
testVar = Variable(torch.LongTensor(testX))
```

It executes successfully but it returns a size of (batch_size*output_labels). Each row is repeated batch_size number of times.