El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

En aquest projecte, aplicarem els coneixements adquirits al llarg del curs per construir un model de Processament del Llenguatge Natural (NLP) utilitzant PyTorch. El nostre objectiu serà crear un model de classificació de text que pugui categoritzar comentaris de clients com a positius o negatius.

Objectius del Projecte

Càrrega i Preprocessament de Dades: Aprendrem a carregar i preprocessar dades textuals.
Construcció del Model: Crearem una xarxa neuronal per a la classificació de text.
Entrenament del Model: Entrenarem el model amb les dades preprocessades.
Avaluació del Model: Avaluarem el rendiment del model utilitzant mètriques adequades.
Desament i Càrrega del Model: Desarem el model entrenat i aprendrem a carregar-lo per a futures prediccions.

Càrrega i Preprocessament de Dades

1.1. Importació de Llibreries Necessàries

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np
import re

1.2. Càrrega de Dades

Per a aquest projecte, utilitzarem un conjunt de dades de comentaris de clients. Suposem que tenim un fitxer CSV amb dues columnes: text (el comentari) i label (0 per negatiu, 1 per positiu).

data = pd.read_csv('customer_reviews.csv')
print(data.head())

1.3. Preprocessament de Text

El preprocessament inclou la neteja del text, la tokenització i la conversió a índexs.

def preprocess_text(text):
    text = text.lower()
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    return text

data['text'] = data['text'].apply(preprocess_text)

1.4. Tokenització i Creació del Vocabulari

from collections import Counter

def tokenize(text):
    return text.split()

data['tokens'] = data['text'].apply(tokenize)

all_tokens = [token for tokens in data['tokens'] for token in tokens]
vocab = Counter(all_tokens)
vocab = {word: idx + 1 for idx, (word, _) in enumerate(vocab.items())}

def encode_tokens(tokens):
    return [vocab[token] for token in tokens]

data['encoded'] = data['tokens'].apply(encode_tokens)

1.5. Padding

def pad_sequences(sequences, maxlen):
    padded = np.zeros((len(sequences), maxlen), dtype=int)
    for i, seq in enumerate(sequences):
        if len(seq) > maxlen:
            padded[i, :maxlen] = seq[:maxlen]
        else:
            padded[i, :len(seq)] = seq
    return padded

maxlen = 100
X = pad_sequences(data['encoded'].values, maxlen)
y = data['label'].values

1.6. Divisió del Conjunt de Dades

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Construcció del Model

2.1. Creació del Dataset Personalitzat

class TextDataset(Dataset):
    def __init__(self, X, y):
        self.X = X
        self.y = y

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

    def __getitem__(self, idx):
        return torch.tensor(self.X[idx], dtype=torch.long), torch.tensor(self.y[idx], dtype=torch.long)

train_dataset = TextDataset(X_train, y_train)
test_dataset = TextDataset(X_test, y_test)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

2.2. Definició de la Xarxa Neuronal

class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embed_size, num_classes):
        super(TextClassifier, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.fc = nn.Linear(embed_size * maxlen, num_classes)

    def forward(self, x):
        x = self.embedding(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

vocab_size = len(vocab) + 1
embed_size = 128
num_classes = 2

model = TextClassifier(vocab_size, embed_size, num_classes)

Entrenament del Model

3.1. Definició de la Funció de Pèrdua i l'Optimitzador

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

3.2. Bucle d'Entrenament

num_epochs = 10

for epoch in range(num_epochs):
    model.train()
    for X_batch, y_batch in train_loader:
        optimizer.zero_grad()
        outputs = model(X_batch)
        loss = criterion(outputs, y_batch)
        loss.backward()
        optimizer.step()
    
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

Avaluació del Model

4.1. Avaluació sobre el Conjunt de Prova

model.eval()
all_preds = []
all_labels = []

with torch.no_grad():
    for X_batch, y_batch in test_loader:
        outputs = model(X_batch)
        _, preds = torch.max(outputs, 1)
        all_preds.extend(preds.numpy())
        all_labels.extend(y_batch.numpy())

accuracy = accuracy_score(all_labels, all_preds)
print(f'Accuracy: {accuracy:.4f}')

Desament i Càrrega del Model

5.1. Desament del Model

torch.save(model.state_dict(), 'text_classifier.pth')

5.2. Càrrega del Model

model = TextClassifier(vocab_size, embed_size, num_classes)
model.load_state_dict(torch.load('text_classifier.pth'))
model.eval()

Conclusió

En aquest projecte, hem après a construir un model de classificació de text utilitzant PyTorch. Hem cobert tot el procés des de la càrrega i preprocessament de dades fins a l'entrenament, avaluació i desament del model. Aquest projecte ens proporciona una base sòlida per abordar problemes de Processament del Llenguatge Natural amb PyTorch.

Projecte de Processament del Llenguatge Natural