Hieronder vind je een overzicht van de stappen om een PyTorch-model op te zetten voor transfer learning met een voorgetraind netwerk, specifiek voor de classificatie van dierenbeelden, inclusief voorbeeldcodefragmenten. **Stap 1: Dataset voorbereiden** - Verzamel en label je dierenbeelden. - Verdeel in trainings-, validatie- en testsets. - Gebruik `torchvision.datasets.ImageFolder` en `transforms` voor preprocessing. ```python import torchvision.transforms as transforms from torchvision.datasets import ImageFolder from torch.utils.data import DataLoader 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]) ]) train_dataset = ImageFolder('path/naar/train', transform=transform) val_dataset = ImageFolder('path/naar/val', transform=transform) train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False) ``` **Stap 2: Het juiste voorgetrainde model selecteren** - Kies een model dat geschikt is qua complexiteit en prestaties, bijvoorbeeld ResNet, VGG, of EfficientNet. - Gebruik `torchvision.models` en let op de input- en outputdimensies. ```python import torchvision.models as models model = models.resnet50(pretrained=True) ``` **Stap 3: Het model aanpassen aan je taak** - Vervang de laatste classifier (fully connected layer) door een nieuwe die past bij jouw aantal diersoorten. ```python num_classes = 10 # bijvoorbeeld 10 soorten dieren import torch.nn as nn # Vervang de laatste laag model.fc = nn.Linear(model.fc.in_features, num_classes) ``` **Stap 4: Bevries de eerste lagen (optioneel)** - Om transfer learning te optimaliseren, kun je de vroege lagen bevriezen zodat ze niet worden getraind. ```python for param in model.parameters(): param.requires_grad = False # Ontgrendel de laatste lagen for param in model.fc.parameters(): param.requires_grad = True ``` **Stap 5: Lossfunctie en optimizer instellen** - Kies een geschikt verlies (bijvoorbeeld `CrossEntropyLoss`) en een optimizer (bijvoorbeeld Adam of SGD), die alleen de parameters die je wilt trainen, bevat. ```python import torch.optim as optim criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=0.001) ``` **Stap 6: Fine-tuning en training** - Voer meerdere epochs uit, waarbij je de modelparameters optimaliseert op je dataset. ```python import torch device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model.to(device) for epoch in range(10): # aantal epochs model.train() for inputs, labels in train_loader: inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # Validatie model.eval() correct = 0 total = 0 with torch.no_grad(): for inputs, labels in val_loader: inputs, labels = inputs.to(device), labels.to(device) outputs = model(inputs) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print(f'Epoch {epoch+1}, Acc: {100 * correct / total:.2f}%') ``` **Stap 7: Model evalueren en verder optimaliseren** - Evalueer op een testdataset. - Pas eventueel hyperparameters aan, of ontdooi meer lagen voor verdere fine-tuning. --- **Samenvatting:** 1. Dataset verzamelen en preprocessen 2. Een geschikt voorgetraind model selecteren 3. Het laatste classificatieblok aanpassen aan je aantal klassen 4. Indien gewenst, vroege lagen bevriezen 5. Loss en optimizer instellen 6. Fine-tuning uitvoeren met meerdere epochs 7. Model evalueren en optimaliseren Met deze stappen en voorbeeldcode kun je effectief transfer learning toepassen voor jouw dierenbeeld classificatie!

Zeker, hier is een stapsgewijze handleiding voor transfer learning in PyTorch voor classificatie van dierenbeelden: ## Stap 1: Vereisten installeren en importeren ```python import torch import torch.nn as nn import torch.optim as optim from torch.optim import lr_scheduler import torchvision from torchvision import datasets, models, transforms import matplotlib.pyplot as plt import time import os import copy ``` ## Stap 2: Selectie van voorgetraind model **Aanbevolen modellen voor dierenclassificatie:** - **ResNet50**: Goede balans tussen nauwkeurigheid en snelheid - **EfficientNet**: Zeer efficiënt met hoge nauwkeurigheid - **Vision Transformer (ViT)**: State-of-the-art voor beeldclassificatie ```python # Model selectie def kies_model(model_naam='resnet50', aantal_klassen=10): if model_naam == 'resnet50': model = models.resnet50(pretrained=True) elif model_naam == 'efficientnet': model = models.efficientnet_b0(pretrained=True) elif model_naam == 'vit': model = models.vit_b_16(pretrained=True) else: raise ValueError("Ongeldig model naam") return model ``` ## Stap 3: Data preprocessing en augmentatie ```python # Data transformaties data_transforms = { 'train': transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.RandomRotation(10), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), 'val': transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]), } # Data laden def laad_data(data_dir): image_datasets = { x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in ['train', 'val'] } dataloaders = { x: torch.utils.data.DataLoader(image_datasets[x], batch_size=32, shuffle=True, num_workers=4) for x in ['train', 'val'] } dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']} class_names = image_datasets['train'].classes return dataloaders, dataset_sizes, class_names ``` ## Stap 4: Model aanpassen voor dierenclassificatie ```python def pas_model_aan(model, aantal_klassen): # Bevries alle lagen eerst for param in model.parameters(): param.requires_grad = False # Aanpassen laatste laag op basis van modeltype if hasattr(model, 'fc'): # ResNet model.fc = nn.Linear(model.fc.in_features, aantal_klassen) elif hasattr(model, 'classifier'): # EfficientNet if hasattr(model.classifier, '1'): model.classifier[1] = nn.Linear(model.classifier[1].in_features, aantal_klassen) else: model.classifier = nn.Linear(model.classifier.in_features, aantal_klassen) elif hasattr(model, 'heads'): # Vision Transformer model.heads.head = nn.Linear(model.heads.head.in_features, aantal_klassen) return model ``` ## Stap 5: Training functie met fine-tuning ```python def train_model(model, dataloaders, dataset_sizes, criterion, optimizer, scheduler, num_epochs=25): since = time.time() best_model_wts = copy.deepcopy(model.state_dict()) best_acc = 0.0 for epoch in range(num_epochs): print(f'Epoch {epoch}/{num_epochs - 1}') print('-' * 10) # Elke epoch heeft training en validatie fase for phase in ['train', 'val']: if phase == 'train': model.train() # Zet model in training modus else: model.eval() # Zet model in evaluatie modus running_loss = 0.0 running_corrects = 0 # Itereer over data for inputs, labels in dataloaders[phase]: inputs = inputs.to(device) labels = labels.to(device) # Zero de parameter gradients optimizer.zero_grad() # Forward pass with torch.set_grad_enabled(phase == 'train'): outputs = model(inputs) _, preds = torch.max(outputs, 1) loss = criterion(outputs, labels) # Backward + optimaliseer alleen in training fase if phase == 'train': loss.backward() optimizer.step() # Statistieken running_loss += loss.item() * inputs.size(0) running_corrects += torch.sum(preds == labels.data) if phase == 'train': scheduler.step() epoch_loss = running_loss / dataset_sizes[phase] epoch_acc = running_corrects.double() / dataset_sizes[phase] print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}') # Kopieer het beste model if phase == 'val' and epoch_acc > best_acc: best_acc = epoch_acc best_model_wts = copy.deepcopy(model.state_dict()) print() time_elapsed = time.time() - since print(f'Training voltooid in {time_elapsed // 60:.0f}m {time_elapsed % 60:.0f}s') print(f'Beste val Acc: {best_acc:.4f}') # Laad beste model gewichten model.load_state_dict(best_model_wets) return model ``` ## Stap 6: Complete implementatie ```python def main(): # Device configuratie device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print(f"Gebruik device: {device}") # Data pad - pas dit aan naar jouw dataset structuur data_dir = 'data/dieren' # Laad data dataloaders, dataset_sizes, class_names = laad_data(data_dir) aantal_klassen = len(class_names) print(f"Aantal klassen: {aantal_klassen}") print(f"Klassen: {class_names}") # Model initialiseren model = kies_model('resnet50', aantal_klassen) model = pas_model_aan(model, aantal_klassen) model = model.to(device) # Loss functie en optimizer criterion = nn.CrossEntropyLoss() # Alleen parameters van de laatste laag trainen initieel optimizer = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9) # Learning rate scheduler exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1) # Fase 1: Alleen laatste laag trainen print("Fase 1: Training laatste laag...") model = train_model(model, dataloaders, dataset_sizes, criterion, optimizer, exp_lr_scheduler, num_epochs=10) # Fase 2: Fine-tuning - ontdooi alle lagen print("Fase 2: Fine-tuning alle lagen...") for param in model.parameters(): param.requires_grad = True # Nieuwe optimizer met lagere learning rate optimizer_ft = optim.SGD(model.parameters(), lr=0.0001, momentum=0.9) exp_lr_scheduler_ft = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) # Fine-tuning model = train_model(model, dataloaders, dataset_sizes, criterion, optimizer_ft, exp_lr_scheduler_ft, num_epochs=15) return model, class_names # Uitvoeren model, class_names = main() ``` ## Stap 7: Model opslaan en laden ```python # Model opslaan torch.save({ 'model_state_dict': model.state_dict(), 'class_names': class_names, 'model_architecture': 'resnet50' }, 'beste_dieren_model.pth') # Model laden voor inferentie def laad_model(model_path, device): checkpoint = torch.load(model_path, map_location=device) model = kies_model(checkpoint['model_architecture'], len(checkpoint['class_names'])) model = pas_model_aan(model, len(checkpoint['class_names'])) model.load_state_dict(checkpoint['model_state_dict']) model.to(device) model.eval() return model, checkpoint['class_names'] # Voorbeeld inferentie def predict_image(image_path, model, class_names, device): transform = data_transforms['val'] image = Image.open(image_path).convert('RGB') image_tensor = transform(image).unsqueeze(0).to(device) with torch.no_grad(): outputs = model(image_tensor) _, predicted = torch.max(outputs, 1) probability = torch.nn.functional.softmax(outputs[0], dim=0) return class_names[predicted.item()], probability[predicted.item()].item() ``` ## Belangrijke tips: 1. **Dataset structuur**: Organiseer je data in mappen `train/val` met submapjes per klasse 2. **Learning rates**: Gebruik lage learning rates (0.001-0.0001) voor fine-tuning 3. **Early stopping**: Stop training wanneer validatie nauwkeurigheid stopt met verbeteren 4. **Data augmentatie**: Cruciaal voor betere generalisatie 5. **Gradient clipping**: Voorkom gradient explosion bij fine-tuning Deze aanpak zou je moeten voorzien van een robuust model voor dierenclassificatie met PyTorch!