Thanks for the information.
I cannot reproduce the error with this minimal code snippet:
import torch
import torch.nn as nn

class EmoLSTM(nn.Module):
    def __init__(self, embedding_matrix, vocab_size, embedding_dim, hidden_units, batch_sz, n_layers, seqLength, device, output_size):
        super(EmoLSTM, self).__init__()
        self.batch_sz = batch_sz
        self.hidden_units = hidden_units
        self.embedding_dim = embedding_dim
        self.vocab_size = vocab_size
        self.output_size = output_size
        self.n_layers = n_layers
        self.seqLength = seqLength

        # layers

        self.embedding = nn.Embedding.from_pretrained(torch.FloatTensor(embedding_matrix))
        self.dropout = nn.Dropout(p=0.5)
        self.lstm = nn.LSTM(self.embedding_dim, self.hidden_units, self.n_layers, bidirectional = False)

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

    def initialize_hidden_state(self, device):
        return torch.zeros(((self.n_layers, self.batch_sz, self.hidden_units))).to(device)

    def forward(self, x, device):
        x = self.embedding(x)
        self.hidden = self.initialize_hidden_state(device)
        h = self.initialize_hidden_state(device)

        output, _ = self.lstm(x, (self.hidden,h) )
        out = output[-1, : , :]
        out = self.fc(out)
        return out, _


num_embeddings = 100
embedding_dim = 300
seq_len = 414
batch_size = 128
device = 'cuda'

model = EmoLSTM(
    embedding_matrix=torch.randn(num_embeddings, embedding_dim),
    vocab_size=num_embeddings,
    embedding_dim=embedding_dim,
    hidden_units=2,
    batch_sz=batch_size,
    n_layers=1,
    seqLength=seq_len,
    device=device,
    output_size=2).to(device)


x = torch.randint(0, num_embeddings, (seq_len, batch_size))
predictions, h = model(x.to(device), device)

Does this code yield the same error on your setup?
If not, could you check what the difference might be between the code snippets?