Natuurlijk! Hier is een stapsgewijze gids voor het toepassen van kennisdestillatie (knowledge distillation) op je ResNet50-model in PyTorch om een kleinere, efficiëntere versie te maken, terwijl je de prestaties zoveel mogelijk behoudt. --- ## Stap 1: Begrijp de kernconcepten - **Teacher-model**: Het grote, nauwkeurige model (bijvoorbeeld ResNet50). - **Student-model**: Het kleinere, efficiëntere model dat je wilt trainen. - **Kennisdestillatie**: Het proces waarbij het student-model leert van de outputs (logits, soft labels) van het teacher-model. - **Loss-functie**: Een combinatie van de gebruikelijke verliesfunctie (bijvoorbeeld cross-entropy) en een distillatieverlies (bijvoorbeeld Kullback-Leibler divergence tussen soft labels). --- ## Stap 2: Voorbereiding van modellen 1. **Laad je teacher-model** (ResNet50): ```python import torchvision.models as models import torch.nn as nn teacher = models.resnet50(pretrained=True) teacher.eval() # Zet in eval-modus ``` 2. **Definieer je student-model**: Je kunt bijvoorbeeld een kleiner model kiezen, zoals ResNet18: ```python student = models.resnet18() ``` --- ## Stap 3: Definieer de loss-functie De distillatie-verliesfunctie combineert: - De standaard cross-entropy loss met de echte labels. - De Kullback-Leibler divergentie tussen de softmax-uitvoer van teacher en student. ```python import torch.nn.functional as F def distillation_loss(student_logits, teacher_logits, labels, T, alpha): """ student_logits: output van student teacher_logits: output van teacher labels: ware labels T: temperatuur alpha: gewicht voor distillatieverlies """ # Hard label verlies ce_loss = F.cross_entropy(student_logits, labels) # Soft labels van teacher en student student_soft = F.log_softmax(student_logits / T, dim=1) teacher_soft = F.softmax(teacher_logits / T, dim=1) # Kullback-Leibler divergentie kd_loss = F.kl_div(student_soft, teacher_soft, reduction='batchmean') * (T ** 2) # Gecombineerde verlies return alpha * kd_loss + (1 - alpha) * ce_loss ``` - `T` (temperatuur) verhoogt de schaal van de softmax-uitvoer, waardoor de kennis van de teacher meer wordt overgedragen. - `alpha` bepaalt de balans tussen de twee verliescomponenten. --- ## Stap 4: Training van de student 1. **Geef de inputs door beide modellen**: ```python for data, labels in dataloader: data, labels = data.to(device), labels.to(device) with torch.no_grad(): teacher_outputs = teacher(data) student_outputs = student(data) loss = distillation_loss(student_outputs, teacher_outputs, labels, T=4.0, alpha=0.7) optimizer.zero_grad() loss.backward() optimizer.step() ``` 2. **Extra tips**: - Zet de teacher in eval-modus en bevries de gewichten. - Experimenteer met de temperatuur `T` en het gewicht `alpha` om optimale prestaties te bereiken. --- ## Stap 5: Evaluatie en finetuning Na training, test je de student op je validatie- of testset om te zien of de prestaties behouden blijven. --- ## Samenvatting | Stap | Beschrijving | | --- | --- | | 1 | Laad teacher en student modellen. | | 2 | Definieer de distillatieverliesfunctie. | | 3 | Train de student met zowel echte labels als de soft labels van de teacher. | | 4 | Evalueer de performance van de getrainde student. | --- ## Extra tips - Gebruik eventueel een aparte validatie- of testset. - Experimenteer met verschillende temperatuur- en gewichtswaarden. - Overweeg data-augmentatie om de generalisatie te verbeteren. --- Als je verdere hulp nodig hebt bij de implementatie of het optimaliseren van je distillatieproces, vraag gerust!

Zeker! Hier is een stapsgewijze gids voor kennisdestillatie met ResNet50 in PyTorch: ## Stap 1: Importeer benodigde bibliotheken ```python import torch import torch.nn as nn import torch.optim as optim import torchvision.transforms as transforms import torchvision.datasets as datasets from torch.utils.data import DataLoader import torchvision.models as models ``` ## Stap 2: Definieer de Knowledge Distillation Loss ```python class DistillationLoss(nn.Module): def __init__(self, temperature=4, alpha=0.7): super().__init__() self.temperature = temperature self.alpha = alpha self.kl_loss = nn.KLDivLoss(reduction='batchmean') self.ce_loss = nn.CrossEntropyLoss() def forward(self, student_logits, teacher_logits, targets): # Soft targets van teacher (gezacht door temperature) soft_teacher = nn.functional.softmax(teacher_logits / self.temperature, dim=1) soft_student = nn.functional.log_softmax(student_logits / self.temperature, dim=1) # Distillation loss distill_loss = self.kl_loss(soft_student, soft_teacher) * (self.temperature ** 2) # Student loss met hard targets student_loss = self.ce_loss(student_logits, targets) # Gecombineerde loss total_loss = self.alpha * distill_loss + (1 - self.alpha) * student_loss return total_loss ``` ## Stap 3: Definieer Student en Teacher Modellen ```python # Teacher model (ResNet50 - groot model) teacher_model = models.resnet50(pretrained=True) teacher_model.fc = nn.Linear(teacher_model.fc.in_features, 1000) # Aanpassen voor jouw dataset # Student model (kleiner model - bijv. ResNet18) student_model = models.resnet18(pretrained=False) student_model.fc = nn.Linear(student_model.fc.in_features, 1000) # Zelfde aantal classes # Zet teacher in evaluation mode teacher_model.eval() for param in teacher_model.parameters(): param.requires_grad = False ``` ## Stap 4: Data Preparation ```python # Data transformaties train_transform = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) val_transform = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) # Data loaders (voorbeeld met CIFAR-100) train_dataset = datasets.CIFAR100(root='./data', train=True, download=True, transform=train_transform) val_dataset = datasets.CIFAR100(root='./data', train=False, download=True, transform=val_transform) train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=128, shuffle=False) ``` ## Stap 5: Training Loop voor Knowledge Distillation ```python def train_distillation(teacher, student, train_loader, val_loader, epochs=50): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') teacher.to(device) student.to(device) # Loss en optimizer criterion = DistillationLoss(temperature=4, alpha=0.7) optimizer = optim.Adam(student.parameters(), lr=0.001) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1) for epoch in range(epochs): # Training student.train() running_loss = 0.0 correct = 0 total = 0 for batch_idx, (inputs, targets) in enumerate(train_loader): inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() # Forward pass with torch.no_grad(): teacher_logits = teacher(inputs) student_logits = student(inputs) # Bereken loss loss = criterion(student_logits, teacher_logits, targets) # Backward pass loss.backward() optimizer.step() running_loss += loss.item() _, predicted = student_logits.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() if batch_idx % 100 == 0: print(f'Epoch: {epoch}, Batch: {batch_idx}, Loss: {loss.item():.4f}') # Validatie student.eval() val_correct = 0 val_total = 0 with torch.no_grad(): for inputs, targets in val_loader: inputs, targets = inputs.to(device), targets.to(device) outputs = student(inputs) _, predicted = outputs.max(1) val_total += targets.size(0) val_correct += predicted.eq(targets).sum().item() train_acc = 100. * correct / total val_acc = 100. * val_correct / val_total print(f'Epoch {epoch}: Train Loss: {running_loss/len(train_loader):.4f}, ' f'Train Acc: {train_acc:.2f}%, Val Acc: {val_acc:.2f}%') scheduler.step() return student # Start training trained_student = train_distillation(teacher_model, student_model, train_loader, val_loader) ``` ## Stap 6: Model Evaluatie en Vergelijking ```python def evaluate_model(model, data_loader, model_name): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.to(device) model.eval() correct = 0 total = 0 with torch.no_grad(): for inputs, targets in data_loader: inputs, targets = inputs.to(device), targets.to(device) outputs = model(inputs) _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() accuracy = 100. * correct / total print(f'{model_name} Accuracy: {accuracy:.2f}%') return accuracy # Vergelijk prestaties teacher_acc = evaluate_model(teacher_model, val_loader, "Teacher") student_acc = evaluate_model(trained_student, val_loader, "Student") print(f"Performance behoud: {student_acc/teacher_acc*100:.2f}%") ``` ## Stap 7: Model Opslaan ```python # Sla het getrainde student model op torch.save(trained_student.state_dict(), 'distilled_resnet18.pth') # Voor later gebruik: # model = models.resnet18(pretrained=False) # model.fc = nn.Linear(model.fc.in_features, 1000) # model.load_state_dict(torch.load('distilled_resnet18.pth')) ``` ## Belangrijke Concepten Uitleg: 1. **Temperature**: Verzacht de softmax verdeling, waardoor de student meer informatie krijgt van de teacher 2. **Alpha**: Balans tussen distillation loss en hard target loss 3. **Soft Targets**: De uitgebreide klasse-informatie van de teacher 4. **Hard Targets**: De werkelijke labels van de dataset ## Tips voor Betere Resultaten: - Experimenteer met temperature (2-8) en alpha (0.5-0.9) - Gebruik learning rate scheduling - Overweeg progressive distillation voor complexe taken - Valideer regelmatig op een testset Deze aanpak zou een significant kleinere ResNet18 moeten opleveren die bijna even goed presteert als de grote ResNet50 teacher!