Réseaux de neurones convolutionnels pour la classification de texte

Apprentissage profond pour le texte avec PyTorch

Shubham Jain

Instructor

CNN pour la classification de texte

Classer des tweets comme
- Positif
- Négatif
- Neutre

L'opération de convolution

Opération de convolution

Opération de convolution
- Faire glisser un filtre (noyau) sur les données d'entrée
- À chaque position, effectuer des calculs élément par élément

Pour le texte : apprend la structure et le sens des mots

¹ Animation de Vincent Dumoulin, Francesco Visin

Filtre et pas dans les CNN

Filtre :
- Petite matrice que l'on fait glisser sur l'entrée

Pas (stride) :
- Nombre de positions parcourues par le filtre

Filtre et pas

¹ Animation de Vincent Dumoulin, Francesco Visin

Architecture CNN pour le texte

Couche de convolution : applique des filtres aux données d'entrée
Couche de regroupement (pooling) : réduit la taille tout en préservant l'information clé
Couche entièrement connectée : produit les prédictions finales à partir de la couche précédente

Implémenter un modèle de classification de texte avec un CNN

class SentimentAnalysisCNN(nn.Module):

    def __init__(self, vocab_size, embed_dim):

        super().__init__()

        self.embedding = nn.Embedding(vocab_size, 
                                         embed_dim)

        self.conv = nn.Conv1d(embed_dim, embed_dim, 
                               kernel_size=3, stride=1, 
                               padding=1)

        self.fc =  nn.Linear(embed_dim, 2)
    ...

La méthode __init__ configure l'architecture
super() initialise la classe de base nn.Module
nn.Embedding crée des vecteurs de mots denses
nn.Conv1d pour des données unidimensionnelles

Implémenter un modèle de classification de texte avec un CNN

    ...
    def forward(self, text):
        embedded = self.embedding(text).permute(0, 2, 1)

        conved = F.relu(self.conv(embedded))

        conved = conved.mean(dim=2)

        return self.fc(conved)

La couche d'intégration convertit le texte en représentations
Adapter les tenseurs au format d'entrée attendu par la convolution
Extraire les caractéristiques clés avec ReLU
Éliminer les dimensions superflues

Préparer les données pour le modèle d'analyse de sentiment

vocab = ["i", "love", "this", "book", "do", "not", "like"]
word_to_idx = {word: i for i, word in enumerate(vocab)}

vocab_size = len(word_to_ix)

embed_dim = 10

book_samples = [
    ("The story was captivating and kept me hooked until the end.".split(),1),
    ("I found the characters shallow and the plot predictable.".split(),0)
]

model = SentimentAnalysisCNN(vocab_size, embed_dim)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

Entraîner le modèle

for epoch in range(10):  
    for sentence, label in data:

        model.zero_grad()

        sentence = torch.LongTensor([word_to_idx.get(w, 0) for w in sentence]).unsqueeze(0)

        outputs = model(sentence)
        label = torch.LongTensor([int(label)])

        loss = criterion(outputs, label)
        loss.backward()

        optimizer.step()

Exécuter le modèle d'analyse de sentiment

for sample in book_samples:

    input_tensor = torch.tensor([word_to_idx[w] for w in sample], dtype=torch.long).unsqueeze(0)

    outputs = model(input_tensor)

    _, predicted_label = torch.max(outputs.data, 1)

    sentiment = "Positive" if predicted_label.item() == 1 else "Negative"

    print(f"Book Review: {' '.join(sample)}")
    print(f"Sentiment: {sentiment}\n")

Book Review: The story was captivating and kept me hooked until the end
Sentiment: Positive
Book Review: I found the characters shallow and the plot predictable
Sentiment: Negative

Passons à la pratique !

Apprentissage profond pour le texte avec PyTorch