I‘m a beginner of Pytorch ,and I try to build a lstm acoustic model, I used merlin’s frontend to prepare data,but my  result is not as good as keras or tensorflow,here is my code，Did I make any mistakes in building the model and training?
class LSTM(nn.Module):
    def __init__(self, embedding_dim, hidden_dim, output_size):
        super(LSTM, self).__init__()
        self.fc1=nn.Linear(embedding_dim,hidden_dim)
        self.fc2=nn.Linear(hidden_dim,hidden_dim)
        self.hidden_dim = hidden_dim
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=2,batch_first=True)
        self.hidden2out = nn.Linear(hidden_dim, output_size)
        self.dropout_layer = nn.Dropout(p=0.1)


    def init_hidden(self, batch_size):
        return (autograd.Variable(torch.randn(2, batch_size, self.hidden_dim)).cuda(),
                autograd.Variable(torch.randn(2, batch_size, self.hidden_dim)).cuda())


    def forward(self,input, lengths):
        self.hidden = self.init_hidden(batch_size)
        input1=torch.tanh(self.fc1(input))
        input2=torch.tanh(self.fc2(input1))
        packed_input = pack_padded_sequence(input2, lengths,batch_first=True)
        outputs, (ht, ct) = self.lstm(packed_input, self.hidden)
        opt,_=pad_packed_sequence(outputs,batch_first=True)
        outputs=self.hidden2out(opt)
        return outputs

model =LSTM(ins,ins,outs).to(device)
optimizer = optim.Adam(model.parameters(), lr=0.002)
for epoch in range(25):  # again, normally you would NOT do 300 epochs, it is toy data
    L = 1
    overall_loss = 0

    for iteration in range(int(len(train_x.keys()) / batch_size) + 1):
        x_batch, y_batch, utt_length_batch = get_batch(train_x, train_y,keys_list,iteration,batch_size)
        if utt_length_batch == []:
            continue
        else:
            L += 1
        max_length_batch = max(utt_length_batch)
        x_batch = data_utils.transform_data_to_3d_matrix(x_batch, max_length=max_length_batch, shuffle_data=False)
        y_batch = data_utils.transform_data_to_3d_matrix(y_batch, max_length=max_length_batch, shuffle_data=False)
    #    for i in range(len(x_batch)):
    #        for s in range(len(x_batch[i])):
    #            temp_x_batch[s][i][:]=x_batch[i][s][:]
     #           temp_y_batch[s][i][:]=y_batch[i][s][:]
        inputs = torch.from_numpy(x_batch).float().to(device)
        tags = torch.from_numpy(y_batch).float().to(device)

        # Also, we need to clear out the hidden state of the LSTM,
        # detaching it from its history on the last instance.
        model.zero_grad()

        # Step 2. Get our inputs ready for the network, that is, turn them into
        # Tensors of word indices.

        # Step 3. Run our forward pass.
        #output,hidden = model(inputs,utt_length_batch)

        pred = model(torch.autograd.Variable(inputs), utt_length_batch)
        loss=criterion(pred,tags)
        loss.backward()
        optimizer.step()
        overall_loss += loss
    print(overall_loss/L)