def forward(self, x):
    x = self.embedding(x)
    x, _ = self.lstm(x)
    x = self.fc(self.dropout(x))
    return x

        # Forward pass
        logits = model(x)
        logits = logits.view(-1, vocab_size)
        y = y.view(-1)

        # Compute loss
        loss = loss_fn(logits, y)

        # Backpropagation
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_loss += loss.item()

    avg_train_loss = total_train_loss / len(train_loader)

    # Validation
    model.eval()
    total_val_loss = 0
    with torch.no_grad():
        for val_x, val_y in val_loader:
            val_x = val_x.to(device)
            val_y = val_y.to(device)

            val_logits = model(val_x)
            val_logits = val_logits.view(-1, vocab_size)
            val_y = val_y.view(-1)

            val_loss = loss_fn(val_logits, val_y)
            total_val_loss += val_loss.item()

    avg_val_loss = total_val_loss / len(val_loader)

    # Append loss values to the lists
    training_losses.append(avg_train_loss)
    validation_losses.append(avg_val_loss)

    print(f'Epoch {epoch + 1}/{max_iters}, Train Loss: {avg_train_loss:.4f}, Validation Loss: {avg_val_loss:.4f}')