Zeker, hier is een implementatie van een cosine annealing scheduler geïntegreerd in een PyTorch trainingslus: ```python import torch import torch.nn as nn import torch.optim as optim from torch.optim.lr_scheduler import CosineAnnealingLR # Stel je model en dataloaders in (voorbeeld) # model = YourModel() # train_loader = YourDataLoader() # Optimizer instellen optimizer = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999)) # Cosine Annealing Scheduler instellen T_max = 50 # Aantal epochs scheduler = CosineAnnealingLR(optimizer, T_max=T_max, eta_min=0) # Trainingslus num_epochs = 50 for epoch in range(num_epochs): model.train() for batch_idx, (data, target) in enumerate(train_loader): # Forward pass output = model(data) loss = criterion(output, target) # Backward pass en optimalisatie optimizer.zero_grad() loss.backward() optimizer.step() # Update learning rate aan het einde van elke epoch scheduler.step() # Huidige learning rate monitoren current_lr = scheduler.get_last_lr()[0] print(f'Epoch {epoch+1}/{num_epochs}, Learning Rate: {current_lr:.6f}, Loss: {loss.item():.4f}') ``` **Uitleg van de implementatie:** 1. **CosineAnnealingLR**: Deze scheduler volgt een cosinusfunctie die de learning rate geleidelijk verlaagt van de initiële waarde naar `eta_min` over `T_max` epochs. 2. **T_max**: Stelt het aantal epochs in voor één complete cosinuscyclus (50 in jouw geval). 3. **eta_min**: Minimale learning rate (0 in dit voorbeeld). 4. **scheduler.step()**: Wordt aan het einde van elke epoch aangeroepen om de learning rate bij te werken. **Alternatieve implementatie met warm-up (optioneel):** ```python from torch.optim.lr_scheduler import SequentialLR, LinearLR, CosineAnnealingLR # Warm-up voor eerste 5 epochs warmup_epochs = 5 scheduler_warmup = LinearLR(optimizer, start_factor=0.1, total_iters=warmup_epochs) scheduler_cosine = CosineAnnealingLR(optimizer, T_max=num_epochs - warmup_epochs, eta_min=0) # Combineer beide schedulers scheduler = SequentialLR( optimizer, schedulers=[scheduler_warmup, scheduler_cosine], milestones=[warmup_epochs] ) ``` **Belangrijke punten:** - De scheduler wordt na elke epoch bijgewerkt, niet na elke batch - Gebruik `scheduler.get_last_lr()` om de huidige learning rate te monitoren - De learning rate daalt volgens: `η_t = η_min + 0.5*(η_initial - η_min)*(1 + cos(T_cur/T_max * π))` Deze aanpak zorgt voor een soepele afname van de learning rate gedurende de training, wat vaak leidt tot betere convergentie en prestaties.