Natuurlijk! Hier is een overzicht van de stappen en voorbeeldcode om een effectief multi-label classificatiemodel in PyTorch te ontwikkelen, afgestemd op jouw dataset: --- ### 1. Gegevensvoorbewerking **a. Normalisatie / Standaardisatie** Omdat je 20 kenmerken hebt, is het belangrijk deze te schalen zodat ze vergelijkbare waarden hebben. ```python from sklearn.preprocessing import StandardScaler import numpy as np # Voorbeeld: gegevens laden X = np.load('features.npy') # shape: (10000, 20) Y = np.load('labels.npy') # shape: (10000, 5) scaler = StandardScaler() X_scaled = scaler.fit_transform(X) ``` **b. Train-Test Split** Gebruik bijvoorbeeld `train_test_split` van scikit-learn: ```python from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split( X_scaled, Y, test_size=0.2, random_state=42) ``` **c. Omzetten naar tensors**: ```python import torch X_train_tensor = torch.tensor(X_train, dtype=torch.float32) y_train_tensor = torch.tensor(y_train, dtype=torch.float32) X_test_tensor = torch.tensor(X_test, dtype=torch.float32) y_test_tensor = torch.tensor(y_test, dtype=torch.float32) ``` --- ### 2. Modelarchitectuur en aanpak Omdat je 5 labels hebt per monster, en elk label een binaire uitkomst is, kun je een eenvoudige feedforward neural network gebruiken met sigmoid-activering aan het einde en binary cross-entropy loss. **a. Modeldefinitie:** ```python import torch.nn as nn class MultiLabelModel(nn.Module): def __init__(self, input_dim=20, hidden_dim=64, output_dim=5): super(MultiLabelModel, self).__init__() self.fc1 = nn.Linear(input_dim, hidden_dim) self.relu = nn.ReLU() self.fc2 = nn.Linear(hidden_dim, output_dim) self.sigmoid = nn.Sigmoid() # voor multi-label classificatie def forward(self, x): x = self.relu(self.fc1(x)) x = self.sigmoid(self.fc2(x)) return x ``` --- ### 3. Selectie van technieken (bijvoorbeeld: classifier chains, binary relevance) **a. Binary relevance:** Dit is eenvoudig: één model voor alle labels, zoals hierboven. Dit werkt goed en is simpel te implementeren. **b. Classifier chains:** Voor complexere relaties tussen labels kun je meerdere modellen gebruiken, waarbij elk model afhankelijk is van de voorspellingen van eerdere labels. Dit vereist meer code en is complexer. Omdat je dataset relatief klein is, raad ik aan te starten met binary relevance. Als je dat wilt uitbreiden, kun je later classifier chains implementeren. --- ### 4. Trainingsstrategieën **a. Lossfunctie:** Gebruik `nn.BCELoss()` of `nn.BCEWithLogitsLoss()`. Het voordeel van `BCEWithLogitsLoss()` is dat je geen sigmoid hoeft toe te passen in je model, omdat deze loss dat automatisch doet. **b. Optimalisatie:** Gebruik bijvoorbeeld Adam. **c. Training loop voorbeeld:** ```python model = MultiLabelModel() criterion = nn.BCEWithLogitsLoss() # geen sigmoid in model optimizer = torch.optim.Adam(model.parameters(), lr=0.001) # Aangepaste forward pass class MultiLabelModel(nn.Module): def __init__(self, input_dim=20, hidden_dim=64, output_dim=5): super(MultiLabelModel, self).__init__() self.fc1 = nn.Linear(input_dim, hidden_dim) self.relu = nn.ReLU() self.fc2 = nn.Linear(hidden_dim, output_dim) def forward(self, x): x = self.relu(self.fc1(x)) x = self.fc2(x) # geen sigmoid hier return x # Training loop for epoch in range(100): model.train() optimizer.zero_grad() outputs = model(X_train_tensor) loss = criterion(outputs, y_train_tensor) loss.backward() optimizer.step() if (epoch+1) % 10 == 0: print(f"Epoch {epoch+1}, Loss: {loss.item()}") ``` **d. Validatie:** ```python model.eval() with torch.no_grad(): val_outputs = model(X_test_tensor) # To interpret: thresholden op 0.5 predicted = (torch.sigmoid(val_outputs) >= 0.5).float() # Bereken bijvoorbeeld nauwkeurigheid per label ``` --- ### 5. Evaluatie Gebruik metrics zoals **Hamming loss**, **Precision**, **Recall**, en **F1-score** voor multi-label classificatie. Scikit-learn biedt functies zoals `classification_report` en `hamming_loss`. ```python from sklearn.metrics import classification_report, hamming_loss y_pred = (torch.sigmoid(val_outputs) >= 0.5).cpu().numpy() print(classification_report(y_test, y_pred)) print('Hamming Loss:', hamming_loss(y_test, y_pred)) ``` --- ### Samenvatting: - **Voorbewerken:** normaliseren, splitten, omzetten naar tensors. - **Model:** eenvoudige feedforward met sigmoid-uitgang en `BCEWithLogitsLoss`. - **Techniek:** binary relevance (één model voor alle labels). - **Training:** optimaliseren met Adam, loss berekenen en model valideren. - **Evaluatie:** gebruik geschikte multi-label metrics. --- Indien je behoefte hebt aan verdere details, uitbreidingen of specifieke codevoorbeelden, laat het gerust weten!

Zeker, ik help je graag met het ontwikkelen van een effectief PyTorch-model voor multi-label classificatie. Hier is een stapsgewijze handleiding met codevoorbeelden. ## 1. Gegevensvoorbewerking ### DataLoader met aangepaste Dataset ```python import torch from torch.utils.data import Dataset, DataLoader import numpy as np from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer class MultiLabelDataset(Dataset): def __init__(self, features, labels): self.features = torch.FloatTensor(features) self.labels = torch.FloatTensor(labels) def __len__(self): return len(self.features) def __getitem__(self, idx): return self.features[idx], self.labels[idx] # Voorbeeld gegevensvoorbereiding # Aannemende: X (10000, 20), y (10000, 5) met binaire labels scaler = StandardScaler() X_scaled = scaler.fit_transform(X) # X is je originele feature matrix # Split data from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split( X_scaled, y, test_size=0.2, random_state=42 ) # DataLoaders train_dataset = MultiLabelDataset(X_train, y_train) test_dataset = MultiLabelDataset(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. Modelarchitecturen ### Optie 1: Binary Relevance (Eenvoudig Neural Network) ```python import torch.nn as nn import torch.nn.functional as F class BinaryRelevanceModel(nn.Module): def __init__(self, input_size, hidden_size, num_labels): super(BinaryRelevanceModel, self).__init__() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size // 2) self.output = nn.Linear(hidden_size // 2, num_labels) self.dropout = nn.Dropout(0.3) def forward(self, x): x = F.relu(self.fc1(x)) x = self.dropout(x) x = F.relu(self.fc2(x)) x = self.dropout(x) x = torch.sigmoid(self.output(x)) return x # Model initialisatie model = BinaryRelevanceModel(input_size=20, hidden_size=64, num_labels=5) ``` ### Optie 2: Classifier Chains ```python class ClassifierChainModel(nn.Module): def __init__(self, input_size, hidden_size, num_labels): super(ClassifierChainModel, self).__init__() self.num_labels = num_labels self.chains = nn.ModuleList() # Maak een keten van classifiers for i in range(num_labels): chain_input_size = input_size + i # Voeg vorige labels toe als features chain = nn.Sequential( nn.Linear(chain_input_size, hidden_size), nn.ReLU(), nn.Dropout(0.3), nn.Linear(hidden_size, 1), nn.Sigmoid() ) self.chains.append(chain) def forward(self, x): batch_size = x.size(0) predictions = [] current_features = x for i in range(self.num_labels): pred = self.chains[i](current_features) predictions.append(pred) # Voeg voorspelling toe aan features voor volgende classifier if i < self.num_labels - 1: current_features = torch.cat([x, torch.cat(predictions, dim=1)], dim=1) return torch.cat(predictions, dim=1) ``` ### Optie 3: Gedeelde Embedding met Task-specifieke Heads ```python class SharedEmbeddingModel(nn.Module): def __init__(self, input_size, hidden_size, num_labels): super(SharedEmbeddingModel, self).__init__() self.shared_backbone = nn.Sequential( nn.Linear(input_size, hidden_size), nn.ReLU(), nn.Dropout(0.3), nn.Linear(hidden_size, hidden_size // 2), nn.ReLU() ) # Task-specifieke heads voor elk label self.heads = nn.ModuleList([ nn.Sequential( nn.Linear(hidden_size // 2, 1), nn.Sigmoid() ) for _ in range(num_labels) ]) def forward(self, x): shared_features = self.shared_backbone(x) outputs = [] for head in self.heads: outputs.append(head(shared_features)) return torch.cat(outputs, dim=1) ``` ## 3. Trainingsstrategieën ### Loss Functie en Optimizer ```python import torch.optim as optim from torch.optim.lr_scheduler import ReduceLROnPlateau # Binary Cross Entropy is standaard voor multi-label criterion = nn.BCELoss() optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4) scheduler = ReduceLROnPlateau(optimizer, mode='min', patience=5, factor=0.5) ``` ### Trainingslus met Early Stopping ```python def train_model(model, train_loader, val_loader, epochs=100): best_val_loss = float('inf') patience = 10 patience_counter = 0 for epoch in range(epochs): # Training model.train() train_loss = 0.0 for batch_features, batch_labels in train_loader: optimizer.zero_grad() outputs = model(batch_features) loss = criterion(outputs, batch_labels) loss.backward() optimizer.step() train_loss += loss.item() # Validatie model.eval() val_loss = 0.0 with torch.no_grad(): for batch_features, batch_labels in val_loader: outputs = model(batch_features) loss = criterion(outputs, batch_labels) val_loss += loss.item() train_loss /= len(train_loader) val_loss /= len(val_loader) scheduler.step(val_loss) # Early stopping if val_loss < best_val_loss: best_val_loss = val_loss patience_counter = 0 torch.save(model.state_dict(), 'best_model.pth') else: patience_counter += 1 if patience_counter >= patience: print(f"Early stopping na epoch {epoch+1}") break if (epoch + 1) % 10 == 0: print(f'Epoch [{epoch+1}/{epochs}], Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}') # Laad beste model model.load_state_dict(torch.load('best_model.pth')) return model ``` ## 4. Evaluatiemetrics ```python from sklearn.metrics import accuracy_score, hamming_loss, f1_score, precision_score, recall_score def evaluate_model(model, test_loader, threshold=0.5): model.eval() all_predictions = [] all_labels = [] with torch.no_grad(): for batch_features, batch_labels in test_loader: outputs = model(batch_features) predictions = (outputs > threshold).float() all_predictions.extend(predictions.cpu().numpy()) all_labels.extend(batch_labels.cpu().numpy()) all_predictions = np.array(all_predictions) all_labels = np.array(all_labels) # Bereken verschillende metrics hamming = hamming_loss(all_labels, all_predictions) accuracy = accuracy_score(all_labels, all_predictions) f1_micro = f1_score(all_labels, all_predictions, average='micro') f1_macro = f1_score(all_labels, all_predictions, average='macro') print(f"Hamming Loss: {hamming:.4f}") print(f"Accuracy: {accuracy:.4f}") print(f"F1 Micro: {f1_micro:.4f}") print(f"F1 Macro: {f1_macro:.4f}") return all_predictions, all_labels ``` ## 5. Gebruiksvoorbeeld ```python # Initialiseer en train model model = BinaryRelevanceModel(input_size=20, hidden_size=64, num_labels=5) trained_model = train_model(model, train_loader, test_loader, epochs=100) # Evalueer model predictions, true_labels = evaluate_model(trained_model, test_loader) # Voorspellingen maken op nieuwe data def predict_new_samples(model, new_features, threshold=0.5): model.eval() with torch.no_grad(): new_features_tensor = torch.FloatTensor(new_features) outputs = model(new_features_tensor) predictions = (outputs > threshold).float() return predictions.numpy() ``` ## Aanbevelingen voor jouw dataset: 1. **Start met Binary Relevance**: Het is eenvoudig en effectief voor 5 labels 2. **Gebruik dropout** (0.3-0.5) om overfitting te voorkomen 3. **Experimenteer met drempelwaarden** (0.3-0.7) voor optimale F1-score 4. **Gebruik learning rate scheduling** voor betere convergentie 5. **Valideer op meerdere metrics** (Hamming loss, F1-micro/macro) Deze aanpak zou goed moeten werken voor je dataset van 10.000 samples met 20 features en 5 labels per sample.