Natuurlijk! Het optimaliseren van hyperparameters is cruciaal voor het verbeteren van je PyTorch-modelprestaties. Hieronder vind je een overzicht van strategieën en voorbeeldcode om ze te implementeren. --- ### 1. Belangrijke hyperparameters voor ConvNet - Leerpercentage (learning rate) - Batchgrootte - Aantal epochs - Optimalisator (bijv. Adam, SGD) - Dropout-rate - Filtergrootte en aantal filters - Regularisatieparameters --- ### 2. Strategieën voor hyperparameterafstemming #### a) Grid Search Systematisch alle combinaties van hyperparameters testen. **Voordeel:** volledig, goed overzicht **Nadeel:** kan traag worden bij veel parameters **Voorbeeld:** ```python import itertools import torch from torch import nn, optim # Definieer hyperparameter sets learning_rates = [0.001, 0.01] batch_sizes = [32, 64] dropouts = [0.3, 0.5] # Alle combinaties combinations = list(itertools.product(learning_rates, batch_sizes, dropouts)) for lr, batch_size, dropout in combinations: # Hier definieer je je model model = ConvNet(dropout=dropout) # Optimizer optimizer = optim.Adam(model.parameters(), lr=lr) # DataLoader met batch_size train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True) # Train je model # ... print(f"Training met lr={lr}, batch_size={batch_size}, dropout={dropout}") # Evalueer model prestaties na training ``` --- #### b) Random Search Gok willekeurig hyperparameters, vaak efficiënter dan grid search. **Voorbeeld:** ```python import random # Hyperparameters define learning_rates = [0.0001, 0.001, 0.01, 0.1] batch_sizes = [16, 32, 64, 128] dropouts = [0.2, 0.3, 0.5, 0.7] # Aantal iteraties n_iterations = 10 for _ in range(n_iterations): lr = random.choice(learning_rates) batch_size = random.choice(batch_sizes) dropout = random.choice(dropouts) model = ConvNet(dropout=dropout) optimizer = optim.Adam(model.parameters(), lr=lr) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True) # Train en evalueer print(f"Random search: lr={lr}, batch_size={batch_size}, dropout={dropout}") # ... ``` --- #### c) Bayesian Optimalisatie Gebruik probabilistische modellen om de hyperparameters te optimaliseren op basis van eerdere resultaten. Populaire bibliotheken: [Optuna](https://optuna.org/), [Hyperopt](http://hyperopt.github.io/). **Voorbeeld met Optuna:** ```python import optuna import torch from torch import nn, optim def objective(trial): # Suggest hyperparameters lr = trial.suggest_loguniform('lr', 1e-5, 1e-1) batch_size = trial.suggest_categorical('batch_size', [32, 64, 128]) dropout = trial.suggest_uniform('dropout', 0.2, 0.7) model = ConvNet(dropout=dropout) optimizer = optim.Adam(model.parameters(), lr=lr) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True) # Train je model kort # ... # Evalueer prestaties op validatieset validation_accuracy = evaluate(model, val_loader) # Doel: maximaliseer validatie nauwkeurigheid return validation_accuracy study = optuna.create_study(direction='maximize') study.optimize(objective, n_trials=50) print("Beste hyperparameters:", study.best_params) ``` --- ### 3. Tips voor effectieve hyperparameterafstemming - Begin met een brede zoekruimte en beperk later. - Gebruik meerdere runs om variatie te minimaliseren. - Combineer grid en random search: start met random, verfijn met grid. - Overweeg automatische methoden zoals Bayesian optimalisatie voor complexere modellen. --- ### 4. Samenvatting - **Grid Search:** volledige dekking, traag bij veel parameters. - **Random Search:** efficiënter bij grote zoekruimten. - **Bayesian Optimalisatie:** slimme, op data gebaseerde verfijning. Door deze strategieën te combineren en gebruik te maken van geschikte tools, kun je je ConvNet aanzienlijk optimaliseren voor betere prestaties! --- Heeft je nog specifieke vragen of wil je hulp met een voorbeeld voor jouw dataset?

Zeker! Hier is een uitgebreide gids voor hyperparameteroptimalisatie van je PyTorch ConvNet, inclusief codevoorbeelden. ## 1. Basisopzet voor Hyperparameteroptimalisatie Eerst definiëren we een flexibele trainingsloop: ```python import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader import torchvision.transforms as transforms class ConvNet(nn.Module): def __init__(self, num_classes=10, dropout_rate=0.5, num_filters=32): super(ConvNet, self).__init__() self.conv1 = nn.Conv2d(3, num_filters, 3, padding=1) self.conv2 = nn.Conv2d(num_filters, num_filters*2, 3, padding=1) self.pool = nn.MaxPool2d(2, 2) self.dropout = nn.Dropout(dropout_rate) self.fc1 = nn.Linear(num_filters*2 * 8 * 8, 128) self.fc2 = nn.Linear(128, num_classes) def forward(self, x): x = self.pool(torch.relu(self.conv1(x))) x = self.pool(torch.relu(self.conv2(x))) x = x.view(x.size(0), -1) x = torch.relu(self.fc1(x)) x = self.dropout(x) x = self.fc2(x) return x def train_model(config, train_loader, val_loader, device): """Trainingsfunctie met configuratie-afhankelijke hyperparameters""" model = ConvNet( dropout_rate=config['dropout_rate'], num_filters=config['num_filters'] ).to(device) optimizer = optim.Adam( model.parameters(), lr=config['learning_rate'], weight_decay=config['weight_decay'] ) criterion = nn.CrossEntropyLoss() # Training model.train() for epoch in range(config['epochs']): for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() # Validatie model.eval() correct = 0 total = 0 with torch.no_grad(): for data, target in val_loader: data, target = data.to(device), target.to(device) outputs = model(data) _, predicted = torch.max(outputs.data, 1) total += target.size(0) correct += (predicted == target).sum().item() accuracy = 100 * correct / total return accuracy ``` ## 2. Grid Search Implementatie ```python from itertools import product def grid_search_hyperparameters(train_loader, val_loader, device): """Grid Search voor hyperparameteroptimalisatie""" # Definieer parameterruimte param_grid = { 'learning_rate': [0.001, 0.01, 0.1], 'dropout_rate': [0.3, 0.5, 0.7], 'num_filters': [32, 64, 128], 'weight_decay': [0, 0.0001, 0.001], 'epochs': [10, 20] } # Genereer alle combinaties keys = param_grid.keys() values = param_grid.values() combinations = [dict(zip(keys, combination)) for combination in product(*values)] best_accuracy = 0 best_params = None results = [] print("Grid Search gestart...") for i, config in enumerate(combinations): print(f"Configuratie {i+1}/{len(combinations)}: {config}") accuracy = train_model(config, train_loader, val_loader, device) results.append((config, accuracy)) if accuracy > best_accuracy: best_accuracy = accuracy best_params = config print(f"\nBeste parameters: {best_params}") print(f"Beste nauwkeurigheid: {best_accuracy:.2f}%") return best_params, best_accuracy, results ``` ## 3. Random Search Implementatie ```python import random def random_search_hyperparameters(train_loader, val_loader, device, n_iter=50): """Random Search voor hyperparameteroptimalisatie""" # Definieer parameterdistributies param_distributions = { 'learning_rate': [0.0001, 0.001, 0.01, 0.1], 'dropout_rate': [0.2, 0.3, 0.4, 0.5, 0.6, 0.7], 'num_filters': [16, 32, 64, 128, 256], 'weight_decay': [0, 0.0001, 0.001, 0.01], 'epochs': [5, 10, 15, 20, 25] } best_accuracy = 0 best_params = None results = [] print("Random Search gestart...") for i in range(n_iter): # Willekeurige configuratie config = { 'learning_rate': random.choice(param_distributions['learning_rate']), 'dropout_rate': random.choice(param_distributions['dropout_rate']), 'num_filters': random.choice(param_distributions['num_filters']), 'weight_decay': random.choice(param_distributions['weight_decay']), 'epochs': random.choice(param_distributions['epochs']) } print(f"Iteratie {i+1}/{n_iter}: {config}") accuracy = train_model(config, train_loader, val_loader, device) results.append((config, accuracy)) if accuracy > best_accuracy: best_accuracy = accuracy best_params = config print(f"\nBeste parameters: {best_params}") print(f"Beste nauwkeurigheid: {best_accuracy:.2f}%") return best_params, best_accuracy, results ``` ## 4. Bayesian Optimalisatie met Optuna ```python import optuna def objective(trial, train_loader, val_loader, device): """Doelfunctie voor Optuna Bayesian optimalisatie""" # Definieer parameterruimte config = { 'learning_rate': trial.suggest_float('learning_rate', 1e-5, 1e-1, log=True), 'dropout_rate': trial.suggest_float('dropout_rate', 0.1, 0.7), 'num_filters': trial.suggest_categorical('num_filters', [16, 32, 64, 128, 256]), 'weight_decay': trial.suggest_float('weight_decay', 1e-6, 1e-2, log=True), 'epochs': trial.suggest_int('epochs', 5, 30) } accuracy = train_model(config, train_loader, val_loader, device) return accuracy def bayesian_optimization(train_loader, val_loader, device, n_trials=100): """Bayesian optimalisatie met Optuna""" study = optuna.create_study(direction='maximize') # Partial functie voor objective objective_partial = lambda trial: objective(trial, train_loader, val_loader, device) study.optimize(objective_partial, n_trials=n_trials) print("\nBayesian Optimalisatie voltooid!") print(f"Beste trial: {study.best_trial.params}") print(f"Beste nauwkeurigheid: {study.best_trial.value:.2f}%") # Visualisatie (optioneel) try: import matplotlib.pyplot as plt optuna.visualization.plot_optimization_history(study) plt.show() except: pass return study.best_params, study.best_trial.value ``` ## 5. Complete Uitvoeringscode ```python def main(): # Setup device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print(f"Gebruik device: {device}") # Voorbeeld dataloaders (vervang met je eigen data) transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) # Voorbeeld met CIFAR-10 from torchvision.datasets import CIFAR10 train_dataset = CIFAR10(root='./data', train=True, download=True, transform=transform) val_dataset = CIFAR10(root='./data', train=False, download=True, transform=transform) train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=128, shuffle=False) print("Kies een optimalisatiemethode:") print("1. Grid Search") print("2. Random Search") print("3. Bayesian Optimalisatie") choice = input("Voer je keuze in (1-3): ") if choice == "1": best_params, best_acc, results = grid_search_hyperparameters( train_loader, val_loader, device ) elif choice == "2": best_params, best_acc, results = random_search_hyperparameters( train_loader, val_loader, device, n_iter=50 ) elif choice == "3": best_params, best_acc = bayesian_optimization( train_loader, val_loader, device, n_trials=50 ) else: print("Ongeldige keuze!") return print(f"\nOptimalisatie voltooid!") print(f"Beste parameters: {best_params}") print(f"Beste validatienauwkeurigheid: {best_acc:.2f}%") if __name__ == "__main__": main() ``` ## 6. Praktische Tips en Strategieën ### Aanbevolen Hyperparameter Ranges: - **Learning rate**: 1e-5 tot 1e-1 (logarithmisch) - **Batch size**: 32, 64, 128, 256 - **Dropout**: 0.1 tot 0.7 - **Weight decay**: 0 tot 1e-2 - **Aantal filters**: machten van 2 (16, 32, 64, 128) ### Optimalisatiestrategie: 1. **Start met Random Search** voor snelle verkenning 2. **Verfijn met Bayesian optimalisatie** voor betere resultaten 3. **Gebruik Grid Search** alleen voor kleine parameterruimtes 4. **Implementeer early stopping** om trainingstijd te reduceren ### Geavanceerde Technieken: ```python # Learning rate scheduler toevoegen scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=5) # Early stopping implementeren class EarlyStopping: def __init__(self, patience=7, min_delta=0): self.patience = patience self.min_delta = min_delta self.counter = 0 self.best_loss = None def __call__(self, val_loss): if self.best_loss is None: self.best_loss = val_loss elif val_loss > self.best_loss - self.min_delta: self.counter += 1 if self.counter >= self.patience: return True else: self.best_loss = val_loss self.counter = 0 return False ``` Deze implementaties geven je een solide basis voor hyperparameteroptimalisatie van je ConvNet. Kies de methode die het beste past bij je rekenbronnen en tijdsbeperkingen!