Natuurlijk! Hier is een overzicht van de essentiële stappen voor het ontwikkelen van een PyTorch-model voor NLP-taken, zoals sentimentanalyse van filmrecensies, inclusief voorbeelden: --- ### 1. Gegevensvoorverwerking **a. Tekstnormalisatie en tokenisatie** - Verwijder leestekens, hoofdletters naar kleine letters, enz. - Tokeniseer de tekst in woorden of subwoorden. **b. Woorden naar indices omzetten (Vocabulary opbouwen)** - Maak een woordenboek (vocab) dat woorden koppelt aan indices. - Voeg speciale tokens toe zoals `<PAD>`, `<UNK>`. **c. Sequenties padding en truncatie** - Zorg dat alle sequenties dezelfde lengte hebben door padding (bijv. met `<PAD>`). **Voorbeeldcode:** ```python import torch from torch.nn.utils.rnn import pad_sequence import re # Sample data texts = ["Deze film was geweldig!", "Niet zo goed..."] labels = [1, 0] # Tokenisatie def tokenize(text): text = text.lower() text = re.sub(r'[^\w\s]', '', text) return text.split() # Build vocabulary vocab = {'<PAD>':0, '<UNK>':1} for text in texts: for word in tokenize(text): if word not in vocab: vocab[word] = len(vocab) # Converteer tekst naar indices def text_to_indices(text, vocab): return [vocab.get(w, vocab['<UNK>']) for w in tokenize(text)] # Converteer alle teksten sequences = [torch.tensor(text_to_indices(t, vocab)) for t in texts] # Padding padded_sequences = pad_sequence(sequences, batch_first=True, padding_value=vocab['<PAD>']) ``` --- ### 2. Modelarchitectuurkeuze Voor NLP-taken wordt vaak gekozen voor: - **Transformers** (bijv. BERT, GPT): krachtige contextuele modellen, maar complexer. - **Recurrent Neural Networks (RNN), LSTM, GRU**: eenvoudiger, effectief voor korte tekst. Voor jouw dataset (filmrecensies), is een eenvoudige LSTM vaak voldoende. **voorbeeld LSTM-model:** ```python import torch.nn as nn class SentimentLSTM(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim): super().__init__() self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0) self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim) self.sigmoid = nn.Sigmoid() def forward(self, x): embeds = self.embedding(x) _, (hidden, _) = self.lstm(embeds) out = self.fc(hidden.squeeze(0)) return self.sigmoid(out) ``` --- ### 3. Trainingsstrategieën - **Lossfunctie:** Gebruik `nn.BCELoss()` voor binaire sentimentclassificatie. - **Optimizer:** Adam of SGD. - **Batchgewijze training:** Gebruik DataLoader voor batching. - **Early stopping:** Stoptraining zodra de validatieprestaties niet verbeteren. - **Learning rate scheduling:** Pas de leersnelheid aan tijdens training. **Voorbeeld training loop:** ```python import torch.optim as optim model = SentimentLSTM(len(vocab), embed_dim=100, hidden_dim=128, output_dim=1) criterion = nn.BCELoss() optimizer = optim.Adam(model.parameters(), lr=0.001) for epoch in range(10): model.train() optimizer.zero_grad() outputs = model(padded_sequences) labels_tensor = torch.tensor(labels, dtype=torch.float32).unsqueeze(1) loss = criterion(outputs, labels_tensor) loss.backward() optimizer.step() print(f"Epoch {epoch+1}, Loss: {loss.item()}") ``` --- ### 4. Extra tips - Overweeg pre-trainingsmodellen zoals BERT voor betere prestaties (via `transformers` bibliotheek). - Gebruik evaluatie- en validatiegegevens om overfitting te voorkomen. - Verdeel je dataset in train/test/validatie. --- ### Samenvatting - **Voorverwerking:** normaliseren, tokeniseren, vocabulaire opbouwen, padding. - **Model:** kiezen tussen RNN/LSTM of Transformer. - **Training:** goede lossfunctie, optimizer, batching, vroegtijdig stoppen. Wil je dat ik een volledige werkende code opzet, of heb je specifieke voorkeuren voor modeltype of dataset?

Zeker, ik help je graag met het ontwikkelen van een PyTorch NLP-model voor sentimentanalyse van filmrecensies. Hier is een stapsgewijze handleiding met codevoorbeelden. ## 1. Gegevensvoorverwerking ```python import torch import torch.nn as nn from torch.utils.data import Dataset, DataLoader from sklearn.model_selection import train_test_split from collections import Counter import re class TextDataset(Dataset): def __init__(self, texts, labels, vocab, max_length=100): self.texts = texts self.labels = labels self.vocab = vocab self.max_length = max_length def __len__(self): return len(self.texts) def __getitem__(self, idx): text = self.texts[idx] label = self.labels[idx] # Tekst naar tokens tokens = self.preprocess_text(text) # Tokens naar indices indices = [self.vocab.get(token, self.vocab['<UNK>']) for token in tokens] # Padding/truncaten if len(indices) < self.max_length: indices += [self.vocab['<PAD>']] * (self.max_length - len(indices)) else: indices = indices[:self.max_length] return torch.tensor(indices), torch.tensor(label) def preprocess_text(self, text): # Basis tekstvoorbewerking text = text.lower() text = re.sub(r'[^a-zA-Z\s]', '', text) tokens = text.split() return tokens # Vocabulaire opbouw def build_vocab(texts, min_freq=2): counter = Counter() for text in texts: tokens = TextDataset.preprocess_text(text) counter.update(tokens) vocab = {'<PAD>': 0, '<UNK>': 1} idx = 2 for word, count in counter.items(): if count >= min_freq: vocab[word] = idx idx += 1 return vocab ``` ## 2. Modelarchitectuur (LSTM + Attention) ```python class SentimentLSTM(nn.Module): def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, dropout): super().__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0) self.lstm = nn.LSTM(embedding_dim, hidden_dim, n_layers, batch_first=True, dropout=dropout, bidirectional=True) self.attention = nn.Sequential( nn.Linear(hidden_dim * 2, hidden_dim), nn.Tanh(), nn.Linear(hidden_dim, 1) ) self.fc = nn.Linear(hidden_dim * 2, output_dim) self.dropout = nn.Dropout(dropout) def forward(self, text): # text shape: [batch_size, seq_len] embedded = self.dropout(self.embedding(text)) # embedded shape: [batch_size, seq_len, embedding_dim] lstm_output, (hidden, cell) = self.lstm(embedded) # lstm_output shape: [batch_size, seq_len, hidden_dim * 2] # Attention mechanisme attention_weights = torch.softmax(self.attention(lstm_output), dim=1) # attention_weights shape: [batch_size, seq_len, 1] weighted_output = torch.sum(attention_weights * lstm_output, dim=1) # weighted_output shape: [batch_size, hidden_dim * 2] return self.fc(weighted_output) # Alternatief Transformer-model class SentimentTransformer(nn.Module): def __init__(self, vocab_size, embedding_dim, nhead, num_layers, output_dim, dropout): super().__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0) encoder_layer = nn.TransformerEncoderLayer( d_model=embedding_dim, nhead=nhead, dropout=dropout, batch_first=True ) self.transformer = nn.TransformerEncoder(encoder_layer, num_layers) self.fc = nn.Linear(embedding_dim, output_dim) self.dropout = nn.Dropout(dropout) def forward(self, text): embedded = self.dropout(self.embedding(text)) # Transformer verwacht [seq_len, batch_size, embedding_dim] transformer_output = self.transformer(embedded) # Gebruik eerste token voor classificatie output = transformer_output[:, 0, :] return self.fc(output) ``` ## 3. Trainingsstrategie en implementatie ```python def train_model(model, train_loader, val_loader, epochs=10, learning_rate=0.001): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = model.to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=2) train_losses = [] val_accuracies = [] for epoch in range(epochs): model.train() total_loss = 0 for batch_idx, (data, targets) in enumerate(train_loader): data, targets = data.to(device), targets.to(device) optimizer.zero_grad() outputs = model(data) loss = criterion(outputs, targets) loss.backward() # Gradient clipping voor stabiliteit torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) optimizer.step() total_loss += loss.item() # Validatie model.eval() correct = 0 total = 0 with torch.no_grad(): for data, targets in val_loader: data, targets = data.to(device), targets.to(device) outputs = model(data) _, predicted = torch.max(outputs.data, 1) total += targets.size(0) correct += (predicted == targets).sum().item() accuracy = 100 * correct / total avg_loss = total_loss / len(train_loader) scheduler.step(avg_loss) print(f'Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}, Val Accuracy: {accuracy:.2f}%') train_losses.append(avg_loss) val_accuracies.append(accuracy) return train_losses, val_accuracies # Hoofdimplementatie def main(): # Aannemende dat je recensies en labels hebt # texts = lijst van recensies # labels = lijst van sentimentlabels (0 voor negatief, 1 voor positief) texts = [...] # Je 10.000 filmrecensies labels = [...] # Bijbehorende labels # Train/validation split train_texts, val_texts, train_labels, val_labels = train_test_split( texts, labels, test_size=0.2, random_state=42 ) # Vocabulaire bouwen vocab = build_vocab(train_texts) # Datasets en DataLoaders train_dataset = TextDataset(train_texts, train_labels, vocab) val_dataset = TextDataset(val_texts, val_labels, vocab) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False) # Model initialiseren vocab_size = len(vocab) model = SentimentLSTM( vocab_size=vocab_size, embedding_dim=100, hidden_dim=128, output_dim=2, # positief/negatief n_layers=2, dropout=0.3 ) # Training starten train_losses, val_accuracies = train_model(model, train_loader, val_loader) # Model opslaan torch.save({ 'model_state_dict': model.state_dict(), 'vocab': vocab, 'model_config': { 'vocab_size': vocab_size, 'embedding_dim': 100, 'hidden_dim': 128, 'output_dim': 2, 'n_layers': 2, 'dropout': 0.3 } }, 'sentiment_model.pth') if __name__ == "__main__": main() ``` ## 4. Gebruik van getraind model ```python def predict_sentiment(model, vocab, text): model.eval() # Tekst voorbewerken dataset = TextDataset([text], [0], vocab) # dummy label input_tensor, _ = dataset[0] input_tensor = input_tensor.unsqueeze(0) # batch dimensie toevoegen with torch.no_grad(): output = model(input_tensor) probabilities = torch.softmax(output, dim=1) predicted_class = torch.argmax(probabilities, dim=1).item() sentiment = "positief" if predicted_class == 1 else "negatief" confidence = probabilities[0][predicted_class].item() return sentiment, confidence # Voorbeeld gebruik # checkpoint = torch.load('sentiment_model.pth') # model = SentimentLSTM(**checkpoint['model_config']) # model.load_state_dict(checkpoint['model_state_dict']) # vocab = checkpoint['vocab'] # sentiment, confidence = predict_sentiment(model, vocab, "Deze film was geweldig!") # print(f"Sentiment: {sentiment}, Betrouwbaarheid: {confidence:.2f}") ``` ## Belangrijke tips: 1. **Gegevensvergroting**: Gebruik synoniemen vervanging of back-translation 2. **Early Stopping**: Stop training wanneer validatieprestaties verslechteren 3. **Learning Rate Scheduling**: Pas learning rate dynamisch aan 4. **Gradient Clipping**: Voorkom gradient explosion in RNNs 5. **Class Balans**: Controleer of je dataset gebalanceerd is Deze implementatie biedt een solide basis voor sentimentanalyse van filmrecensies en kan worden aangepast voor specifieke vereisten.