Pytorch: Richtige Verwendung benutzerdefinierter Gewichtskarten in unet-Architekturen

Es gibt einen berühmten Trick in der U-Net-Architektur, benutzerdefinierte Gewichtskarten zu verwenden, um die Genauigkeit zu erhöhen.

Wenn ich hier und an mehreren anderen Stellen frage, lerne ich zwei Ansätze kennen. Ich möchte wissen, welcher richtig ist, oder gibt es einen anderen richtigen Ansatz, der korrekter ist?

1) Zuerst ist die torch.nn.FunctionalMethode in der Trainingsschleife zu verwenden.

loss = torch.nn.functional.cross_entropy(output, target, w) Dabei ist w das berechnete benutzerdefinierte Gewicht.

2) Zweitens ist reduction='none'beim Aufrufen der Verlustfunktion außerhalb der Trainingsschleife zu verwenden criterion = torch.nn.CrossEntropy(reduction='none')

und dann in der Trainingsschleife mit dem benutzerdefinierten Gewicht multiplizieren-

gt # Ground truth, format torch.long
pd # Network output
W # per-element weighting based on the distance map from UNet
loss = criterion(pd, gt)
loss = W*loss # Ensure that weights are scaled appropriately
loss = torch.sum(loss.flatten(start_dim=1), axis=0) # Sums the loss per image
loss = torch.mean(loss) # Average across a batch

Jetzt bin ich ein bisschen verwirrt, welches richtig ist oder gibt es einen anderen Weg oder beide sind richtig?

Der Gewichtungsabschnitt sieht aus wie eine einfach gewichtete Kreuzentropie, die für die Anzahl der Klassen (2 im folgenden Beispiel) so ausgeführt wird.

weights = torch.FloatTensor([.3, .7])
loss_func = nn.CrossEntropyLoss(weight=weights)

BEARBEITEN:

Haben Sie diese Implementierung von Patrick Black gesehen?

# Set properties
batch_size = 10
out_channels = 2
W = 10
H = 10

# Initialize logits etc. with random
logits = torch.FloatTensor(batch_size, out_channels, H, W).normal_()
target = torch.LongTensor(batch_size, H, W).random_(0, out_channels)
weights = torch.FloatTensor(batch_size, 1, H, W).random_(1, 3)

# Calculate log probabilities
logp = F.log_softmax(logits)

# Gather log probabilities with respect to target
logp = logp.gather(1, target.view(batch_size, 1, H, W))

# Multiply with weights
weighted_logp = (logp * weights).view(batch_size, -1)

# Rescale so that loss is in approx. same interval
weighted_loss = weighted_logp.sum(1) / weights.view(batch_size, -1).sum(1)

# Average over mini-batch
weighted_loss = -1. * weighted_loss.mean()

Beachten Sie, dass torch.nn.CrossEntropyLoss () eine Klasse ist, die torch.nn.functional aufruft. Siehe https://pytorch.org/docs/stable/_modules/torch/nn/modules/loss.html#CrossEntropyLoss

Sie können die Gewichte verwenden, wenn Sie die Kriterien definieren. Wenn man sie funktional vergleicht, sind beide Methoden gleich.

Nun, ich verstehe Ihre Idee, Verluste innerhalb der Trainingsschleife in Methode 1 und außerhalb der Trainingsschleife in Methode 2 zu berechnen, nicht. Wenn Sie Verluste außerhalb der Schleife berechnen, wie werden Sie dann rückpropagieren?