Hi, I am working on sentiment analysis. I converted my text to word2vec embeddings using genism. Now, I am passing these encoded vectors to lstm as inputs and using lstm to classify sentiment of the text. But, the isssue that I am facing is that for training my loss decreases throughout and accuracy increases to 95% almost. But for my validation loss decreases for few epochs but then it start increasing might be because of over-fitting. The validation accuracy is stuck and fluctuates between 49 and 51. I am not sure what the problem is. This is my first time working on NLP. Kindly, help me out.
Sentiments 0 and 1
Activation = Sigmoid
Learning rate = 5e-3
loss = BCEloss
optimizer = SGD
Code:
class LSTMSentimentNet(nn.Module):
def __init__(self, vocab_size, output_size, embedding_dim, hidden_dim, n_layers, word_embeddings, drop_prob=0.64):

    super(LSTMSentimentNet, self).__init__()

    self.output_size = output_size

    self.n_layers = n_layers

    self.hidden_dim = hidden_dim

    

    self.embedding = nn.Embedding(vocab_size, embedding_dim)

    self.embedding.weight = nn.Parameter(word_embeddings, requires_grad=False)

    self.lstm = nn.LSTM(embedding_dim, hidden_dim, n_layers, dropout=drop_prob, batch_first=True, bidirectional=True)

    self.dropout = nn.Dropout(drop_prob)

    self.fc = nn.Linear(hidden_dim, output_size)

    self.sigmoid = nn.Sigmoid()

    

def forward (self, input_words):

    input_words = input_words.long()           

    embedded_words = self.embedding(input_words)  

    lstm_out, h = self.lstm(embedded_words)        
    lstm_out = self.dropout(lstm_out)

    lstm_out = lstm_out.contiguous().view(-1, self.hidden_dim) 
    fc_out = self.fc(lstm_out)                    
    sigmoid_out = self.sigmoid(fc_out)          

    sigmoid_out = sigmoid_out.view(batch_size, -1)

    sigmoid_last = sigmoid_out[:, -1]            

    return sigmoid_last, h

def init_hidden(self, batch_size):

    weight = next(self.parameters()).data

    if (is_cuda):

        hidden = (weight.new(self.n_layers*2, batch_size, self.hidden_dim).zero_().cuda(),

                     weight.new(self.n_layers*2, batch_size, self.hidden_dim).zero_().cuda())

    else:

        hidden = (weight.new(self.n_layers*2, batch_size, self.hidden_dim).zero_(),

                      weight.new(self.n_layers*2, batch_size, self.hidden_dim).zero_())

    return hidden


Training
for i in range(epochs):
h = model.init_hidden(batch_size)

num_correct = 0

val_correct = 0

model.train()

print('Epoch: {}/{}...'.format(i+1, epochs))

for inputs, labels in train_loader:

    h = tuple([e.data for e in h])

    inputs, labels = inputs.to(device), labels.to(device)

    model.zero_grad()

    output, h = model(inputs)

    loss = criterion(output.unsqueeze(1), labels.float())

    loss.backward()

    nn.utils.clip_grad_norm_(model.parameters(), clip)

    optimizer.step()

    pred = torch.round(output.squeeze())  # Rounds the output to 0/1

    correct_tensor = pred.eq(labels.float().view_as(pred))

    correct = np.squeeze(correct_tensor.cpu().numpy())

    num_correct += np.sum(correct)

train_acc = num_correct/len(train_loader.dataset)

print("\tTrain Loss: {:.6f}".format(loss.item())+", Train accuracy: {:.3f}%".format(train_acc*100))

            

with torch.no_grad():

    model.eval()

    val_h = model.init_hidden(batch_size)

    val_losses = []

    for inp, target in val_loader:

        val_h = tuple([each.data for each in val_h])

        inp, target = inp.to(device), target.to(device)

        out, val_h = model(inp)

        val_loss = criterion(out.unsqueeze(1), target.float())

        val_losses.append(val_loss.item())

        val_pred = torch.round(out.squeeze())  # Rounds the output to 0/1

        val_correct_tensor = pred.eq(target.float().view_as(val_pred))

        corrects = np.squeeze(val_correct_tensor.cpu().numpy())

        val_correct += np.sum(corrects)

    val_acc = val_correct/len(val_loader.dataset)

    print("\tValidation Loss: {:.6f}".format(val_loss)+", Validation accuracy: {:.3f}%".format(val_acc*100))