Réseaux neuronaux récurrents pour la classification de texte

Apprentissage profond pour le texte avec PyTorch

Shubham Jain

Data Scientist

RNN pour le texte

Gèrent des séquences de longueurs variables
Maintiennent une mémoire interne à court terme
Les CNN repèrent des motifs par segments
Les RNN retiennent les mots passés pour mieux saisir le sens

RNN pour la classification de texte

Image de sarcasme

Pourquoi ?

Les RNN lisent les phrases comme les humains, un mot à la fois
Comprennent le contexte et l'ordre

Exemple : détecter le sarcasme dans un tweet

« I just love getting stuck in traffic. »

Sarcastique

Récap : implémenter Dataset et DataLoader

# Import libraries
from torch.utils.data import Dataset, DataLoader

# Create a class
class TextDataset(Dataset):

    def __init__(self, text):
        self.text = text

    def __len__(self):
        return len(self.text)

    def __getitem__(self, idx):
        return self.text[idx]

Implémentation d'un RNN

sample_tweet = "This movie had a great plot and amazing acting."
# Preprocess the review and convert it to a tensor (not shown for brevity)
# ...
sentiment_prediction = model(sample_tweet_tensor)

Entraîner un modèle RNN pour classer un tweet comme positif ou négatif
Sortie : « Positive »

Variation de RNN : LSTM

Image d'analyse de sentiment

Tweet :

  « Loved the cinematography, 
  hated the dialogue. 
  The acting was exceptional,
  but the plot fell flat. »

Les LSTM (Long Short Term Memory) saisissent des cas complexes où les RNN peinent

LSTM

Architecture LSTM : porte d'entrée, porte d'oubli et porte de sortie

class LSTMModel(nn.Module):

    def __init__(self, input_size, hidden_size, output_size):
        super(LSTMModel, self).__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)


    def forward(self, x):
        _, (hidden, _) = self.lstm(x)
        output = self.fc(hidden.squeeze(0))
        return output

Variation de RNN : GRU

Objet du courriel :

   « Congratulations!
    You've won a free trip 
    to Hawaii! »

La Gated Recurrent Unit (GRU) reconnaît vite des motifs de pourriel sans tout le contexte

Pourriel

GRU

class GRUModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(GRUModel, self).__init__()
        self.gru = nn.GRU(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        _, hidden = self.gru(x)
        output = self.fc(hidden.squeeze(0))
        return output

Passons à la pratique !