Réseaux de neurones convolutifs pour la classification de texte

Deep Learning pour le texte avec PyTorch

Shubham Jain

Instructor

CNN pour la classification des textes

"- Classifier les tweets comme

- Positif

L'opération de convolution

" Opération de convolution "

"- Opération de convolution

Déplacement d’un filtre (noyau) sur les données d’entrée
Pour chaque position du filtre, effectuer des calculs élément par élément

Pour le texte : apprend la structure et le sens des mots {{2}}"

¹ 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 :
- Nombre de positions que le filtre se déplace {{2}}"

" 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 pooling : réduit la taille des données tout en préservant les informations importantes
Couche entièrement connectée : effectue les prédictions finales à partir de la sortie de la couche précédente {{3}}"

Mise en œuvre d’un modèle de classification de texte utilisant un CNN

"`python class SentimentAnalysisCNN(nn.Module):


----CODE_GLUE----
```python
    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)

----CODE_GLUE---- python self.fc = nn.Linear(embed_dim, 2) ...{{6}}"

"- 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 {{5}}"

Mise en œuvre d’un modèle de classification de texte utilisant un CNN

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


----CODE_GLUE----
```python
        conved = F.relu(self.conv(embedded))

        conved = conved.mean(dim=2)

----CODE_GLUE---- python return self.fc(conved){{4}}"

"- La couche d'embedding convertit le texte en embedding

Faites correspondre les tenseurs à l'entrée attendue de la couche de convolution
Extrayez les caractéristiques importantes avec ReLU
Éliminez les couches et dimensions supplémentaires {{4}}"

Préparation des données pour le modèle d’analyse de sentiment

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


----CODE_GLUE----
```python
vocab_size = len(word_to_ix)

embed_dim = 10

book_samples = [
    (\"L'histoire était captivante et m'a tenu en haleine jusqu'à la fin.\".split(),1),
    (\"J'ai trouvé les personnages superficiels et l'intrigue prévisible.\".split(),0)
]

----CODE_GLUE---- python model = SentimentAnalysisCNN(vocab_size, embed_dim) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.1){{5}}"

Entraîner le modèle

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

Exécution du modèle d’analyse de sentiment

"python for sample in book_samples:

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

Passons à la pratique !

Deep Learning pour le texte avec PyTorch