Sequence Classification with PyTorch RNN ✅

import numpy as np
import torch
import torch.nn as nn
import torch.functional as functional
from torch.optim import Adam

import mytext
from torchtext.data import get_tokenizer

tokenizer = get_tokenizer('basic_english')

(reviews, targets) = mytext.imdb_reviews(tokenizer)

voc = mytext.build_vocab(reviews)

reviews_tensor = mytext.build_tensor(reviews, voc)
inputs_tensor = reviews_tensor[:, :100]
targets_tensor = torch.tensor(targets, dtype=torch.long)

from torch.utils.data import TensorDataset, DataLoader

dataset = TensorDataset(inputs_tensor, targets_tensor)
dataloader = DataLoader(dataset, batch_size=64, shuffle=True)

class SeqClassifier(nn.Module):
    def __init__(self, voc_size, input_dim, state_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(voc_size, input_dim)
        self.rnn = nn.RNN(input_dim, state_dim, batch_first=True)
        self.fc = nn.Linear(state_dim, output_dim)
    def forward(self, tokens):
        x = self.embedding(tokens)
        x, _ = self.rnn(x)
        x = x[:, -1, :]
        x = self.fc(x)
        return x

epochs = 5
input_dim = 32
state_dim = 64
model = SeqClassifier(len(voc), input_dim, state_dim, 2)
loss = nn.CrossEntropyLoss()
optimizer = Adam(model.parameters())

for epoch in range(epochs):
    losses = []
    for (x, target) in dataloader:
        y = model(x)
        l = loss(y, target)
        l.backward()
        optimizer.step()
        optimizer.zero_grad()
        losses.append(l.item())
    l = np.mean(losses)
    print("{}: loss={:.4f}".format(epoch, l))

0: loss=0.6957
1: loss=0.6932
2: loss=0.6885
3: loss=0.6837
4: loss=0.6764

#
# Evaluate
#
from torchmetrics import Accuracy

with torch.no_grad():
    success = 0
    total = 0
    for x, target in dataloader:
        y = model(x)
        pred = y.argmax(axis=1)
        success += (pred == target).sum()
        total += target.shape[0]
    print("Accuracy = {:.2f}".format(success/total))

Accuracy = 0.57