Hello,

I am implementing a text classification. For which I need to customize the LSTMCell hence was trying out between LSTM and LSTMCell(performance is not a factor in this case)

Here is my code for the lstmCell implementation:

class RNN(nn.Module):

```
def __init__(self, vocab_size, embed_size, num_output, hidden_size=64,
num_layers=2, batch_first=True, use_gpu=False, embeddings = None):
'''
:param vocab_size: vocab size
:param embed_size: embedding size
:param num_output: number of output (classes)
:param hidden_size: hidden size of rnn module
:param num_layers: number of layers in rnn module
:param batch_first: batch first option
'''
super(RNN, self).__init__()
# embedding
self.embedding_dim = embed_size
self.encoder = nn.Embedding(vocab_size, embed_size, padding_idx=0)
if embeddings is not None:
self.encoder.weight = nn.Parameter(embeddings)
self.batch_first = batch_first
self.drop_en = nn.Dropout(p=0.8)
self.use_gpu = use_gpu
self.hidden_dim = hidden_size
# rnn module
self.rnn = nn.LSTM(
input_size=embed_size,
hidden_size=hidden_size,
num_layers=num_layers,
dropout=0.0,
batch_first=True,
bidirectional=False
)
self.rnncell = nn.LSTMCell(
input_size=embed_size,
hidden_size=hidden_size
)
self.bn2 = nn.BatchNorm1d(hidden_size)
self.fc = nn.Linear(hidden_size, num_output)
self.hidden = self.init_hidden(128)
def init_hidden(self, batch_size):
if self.use_gpu:
hx = Variable(torch.zeros(batch_size, self.hidden_dim), requires_grad=False).cuda()
cx = Variable(torch.zeros(batch_size, self.hidden_dim), requires_grad=False).cuda()
else:
hx = Variable(torch.zeros(batch_size, self.hidden_dim))
cx = Variable(torch.zeros(batch_size, self.hidden_dim))
return hx, cx
def forward(self, x, seq_lengths):
'''
:param x: (batch, time_step, input_size)
:return: num_output size
'''
hx, cx = self.hidden
x_embed = self.encoder(x)
x_embed = self.drop_en(x_embed)
#x_embed = x_embed.view(x_embed.size(1), x_embed.size(0), -1)
x_embed = x_embed.transpose(0, 1)
#print x_embed.size()
#packed_input = pack_padded_sequence(x_embed, seq_lengths.cpu().numpy(), batch_first=self.batch_first)
#x = x.view(x_embed.size(1), x_embed.size(0), self.embedding_dim)
#x_embed = x_embed.transpose(0, 1)
# r_out shape (batch, time_step, output_size)
# None is for initial hidden state
yhat = []
for j in range(x_embed.size(0)):
input_t = x_embed[j]
#print input_t.size()
hx, cx = self.rnncell(input_t, (hx, cx))
# print hx.size()
yhat.append(hx)
#ht, ct = self.rnn(x_embed, self.hidden)
#print ht.size()
# use mean of outputs
#out_rnn, _ = pad_packed_sequence(packed_output, batch_first=True)
#row_indices = torch.arange(0, x.size(0)).long()
#col_indices = seq_lengths - 1
#if next(self.parameters()).is_cuda:
# row_indices = row_indices.cuda()
# col_indices = col_indices.cuda()
last_tensor = yhat[-1]
#last_tensor = ht[-1]
#print last_tensor.size()
#fc_input = torch.mean(last_tensor, dim=1)
#last_tensor = ht[:-1]
fc_input = self.bn2(last_tensor)
out = self.fc(fc_input)
#print out.size()
return out
```

The difference in the performances is huge, am I doing something wrong here?

By performance I meant classification accuracy.

Thanks in advance.