It helped. Thank you
I am novice in pytorch. I have written a simple RNN with glove embedding today, but the loss is not decreasing. It will be helpful if you find some time for suggessions.
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
import numpy as np


import pickle

with open("/content/word2index.pickle",'rb') as out:
    word2index = pickle.load(out)


with open("/content/train_data.pickle",'rb') as out:
    train = pickle.load(out)

with open("/content/val_data.pickle",'rb') as out:
    val = pickle.load(out)

with open("/content/test_data.pickle",'rb') as out:
    test = pickle.load(out)

with open("/content/word2index.pickle",'rb') as out:
    word2index = pickle.load(out)

import pickle
with open("/content/dic.pickle",'rb') as out:
    model=pickle.load(out)
embedding_matrix = np.zeros((len(word2index) + 1, 300))
for k,v in model.items():
    embedding_matrix[k]=v

weight = torch.FloatTensor(embedding_matrix)#customized glove embeddings

embedding = nn.Embedding.from_pretrained(weight)

MAXLEN=0
def sequence(word2index,mode):   #returns index for words and its y label
  sequence=[]
  y_seq=[]
  for s in mode:
    text = s.split('__split__')[0]
    y = s.split('__split__')[1]
    one_seq=[]
    words= text.split(' ')
    global MAXLEN
    if(len(words)>MAXLEN):
      MAXLEN= len(words)

    for w in words:
      if (w in word2index.keys()):
        one_seq.append(word2index[w])
      else:
        one_seq.append(1)
    sequence.append(one_seq)
    y_seq.append(y)
  return sequence,y_seq

sequence,y_seq = sequence(word2index,train)

from keras.preprocessing.sequence import pad_sequences
X = pad_sequences(sequence, maxlen=MAXLEN,padding='post',truncating='post')
input =torch.LongTensor(X)
embeded_train = embedding(input)

batch_size = 32
dataset = TensorDataset(embeded_train, labels)
loader = DataLoader(dataset, batch_size=batch_size)

num_classes = 9
num_epochs = 10

learning_rate = 0.001

input_size = embeded_train.shape[2]
sequence_length = embeded_train.shape[1]
hidden_size = 128
num_layers = 5
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, num_classes):
        super(RNN, self).__init__()
        self.num_layers = num_layers
        self.hidden_size = hidden_size
        self.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, num_classes)
        
    def forward(self, x):
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size).to(device) 
        out, _ = self.rnn(x, h0) 
        out = out[:, -1, :]
        out1 = self.fc(out)
        return out1

model = RNN(input_size, hidden_size, num_layers, num_classes).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

for epoch in range(num_epochs):
  for x,y in loader:
    output = model(x)
    loss = criterion(output,y)
    acc = binary_accuracy(predictions, batch.Label)
    loss.backward()
    optimizer.zero_grad()
    optimizer.step()
    if (epoch+1) % 5 == 0:
      print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))