Reti neurali convoluzionali per la classificazione del testo

Deep Learning per il testo con PyTorch

Shubham Jain

Instructor

CNN per la classificazione del testo

Classificare i tweet come
- Positivi
- Negativi
- Neutri

L'operazione di convoluzione

Operazione di convoluzione

Operazione di convoluzione
- Scorrere un filtro (kernel) sui dati di input
- Per ogni posizione del filtro, calcolare elemento per elemento

Per il testo: apprende struttura e significato delle parole

¹ Animazione di Vincent Dumoulin, Francesco Visin

Filtro e stride nelle CNN

Filtro:
- Piccola matrice che scorriamo sull'input

Stride:
- Numero di posizioni di avanzamento del filtro

Filtro e stride

¹ Animazione di Vincent Dumoulin, Francesco Visin

Architettura CNN per il testo

Convolutional layer: applica filtri ai dati di input
Pooling layer: riduce la dimensione preservando le info importanti
Fully connected layer: fa le previsioni finali dal risultato precedente

Implementare un modello di classificazione testuale con 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)
    ...

Il metodo __init__ configura l'architettura
super() inizializza la classe base nn.Module
nn.Embedding crea vettori densi di parole
nn.Conv1d per dati monodimensionali

Implementare un modello di classificazione testuale con 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)

L'Embedding layer converte il testo in embedding
Allinea i tensori all'input atteso dalla convoluzione
Estrai feature chiave con ReLU
Elimina livelli e dimensioni superflue

Preparare i dati per il modello di sentiment analysis

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)

Addestrare il modello

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()

Eseguire il modello di sentiment analysis

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

Esercitiamoci!

Deep Learning per il testo con PyTorch