Hier is een voorbeeld van een aangepaste lossfunctie in PyTorch die beter geschikt is voor een zeldzame positieve klasse bij binaire classificatie, namelijk de gewogen BCE (Binary Cross Entropy) loss. Deze gewogen versie past de bijdrage van positieve en negatieve voorbeelden aan, waardoor de zeldzame positieve klasse meer gewicht krijgt. ```python import torch import torch.nn as nn class WeightedBCELoss(nn.Module): def __init__(self, pos_weight): super(WeightedBCELoss, self).__init__() # pos_weight is een scalar die het gewicht voor de positieve klasse aangeeft self.pos_weight = pos_weight self.bce = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([pos_weight])) def forward(self, logits, targets): return self.bce(logits, targets) ``` **Hoe te gebruiken:** 1. Bepaal het gewicht voor de positieve klasse, bijvoorbeeld door de frequentie van negatieve en positieve voorbeelden te bekijken: ```python pos_weight = (aantal_negatieve voorbeelden) / (aantal_positieve voorbeelden) ``` 2. Maak een instantie van je lossfunctie met dat gewicht: ```python loss_fn = WeightedBCELoss(pos_weight=pos_weight) ``` 3. Tijdens je training, gebruik je deze lossfunctie in je trainingslus: ```python for data, labels in dataloop: optimizer.zero_grad() outputs = model(data) # logits loss = loss_fn(outputs, labels.float()) loss.backward() optimizer.step() ``` **Extra tips:** - Zorg dat je labels float zijn (0.0 en 1.0). - Het gebruik van `BCEWithLogitsLoss` wordt aanbevolen omdat het numeriek stabieler is dan het combineren van sigmoid en BCELoss. - Pas `pos_weight` aan op basis van je dataset om de zeldzame klasse te benadrukken. **Kort samengevat:** Deze aanpak verhoogt de stimulans voor het model om de zeldzame positieve klasse correct te classificeren, door de loss voor positieve voorbeelden zwaarder te maken.

Hier is een implementatie van een gewogen binary cross-entropy loss functie voor onbalans in binaire classificatie: ```python import torch import torch.nn as nn import torch.nn.functional as F class WeightedBCELoss(nn.Module): def __init__(self, pos_weight=None, weight=None): """ Gewogen Binary Cross Entropy Loss voor onbalans Args: pos_weight (Tensor): Gewicht voor positieve klasse (zeldzame klasse) weight (Tensor): Gewicht voor beide klassen [neg_weight, pos_weight] """ super(WeightedBCELoss, self).__init__() self.pos_weight = pos_weight self.weight = weight def forward(self, input, target): """ Args: input (Tensor): Model output (logits) target (Tensor): Ground truth labels (0 of 1) """ # Optioneel: sigmoid toepassen als input logits zijn # probabilities = torch.sigmoid(input) if self.pos_weight is not None: # Gebruik built-in weighted BCE met logits return F.binary_cross_entropy_with_logits( input, target, pos_weight=self.pos_weight, weight=self.weight ) else: return F.binary_cross_entropy_with_logits(input, target, weight=self.weight) # Alternatief: Focal Loss voor sterk onbalans class FocalLoss(nn.Module): def __init__(self, alpha=0.25, gamma=2.0): """ Focal Loss voor extreme klasse onbalans Args: alpha: Balanceringsparameter voor zeldzame klasse gamma: Focusing parameter (hoe hoger, meer focus op moeilijke voorbeelden) """ super(FocalLoss, self).__init__() self.alpha = alpha self.gamma = gamma def forward(self, input, target): BCE_loss = F.binary_cross_entropy_with_logits(input, target, reduction='none') pt = torch.exp(-BCE_loss) # p_t focal_loss = self.alpha * (1-pt)**self.gamma * BCE_loss return focal_loss.mean() ``` **Integratie in je trainingslus:** ```python # Voorbereiding device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Bereken klasse gewichten (optioneel, maar aanbevolen) # Stel: 95% negatief, 5% positief pos_weight = torch.tensor([5.0]) # 1/0.05 = 20, maar 5 is vaak voldoende # Initialiseer loss functie criterion = WeightedBCELoss(pos_weight=pos_weight.to(device)) # OF voor extreme onbalans: # criterion = FocalLoss(alpha=0.8, gamma=2.0) # In je trainingslus for epoch in range(num_epochs): model.train() for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(device), target.to(device).float() optimizer.zero_grad() output = model(data) # Bereken loss met aangepaste functie loss = criterion(output.squeeze(), target) loss.backward() optimizer.step() ``` **Uitleg van de aanpak:** 1. **Weighted BCE**: Geeft meer gewicht aan de zeldzame (positieve) klasse 2. **Focal Loss**: Richt zich op moeilijk te classificeren voorbeelden 3. **pos_weight**: Typisch ingesteld als ratio negatief/positief (bijv. 19:1 → pos_weight=19) 4. **alpha in Focal Loss**: Balanseert belang van positieve vs negatieve voorbeelden **Aanbevelingen:** - Bereken exacte klasse verhoudingen uit je dataset - Experimenteer met verschillende gewichten (begin met 1/positief_ratio) - Overweeg Focal Loss voor extreme onbalans (>1:100) - Monitor zowel loss als metrics zoals F1-score, precision, recall Deze aanpak helpt je model effectief leren van de zeldzame positieve voorbeelden zonder overmatig te focussen op de dominante negatieve klasse.