def trainaccuracy():
with torch.no_grad():
net.eval()
good, tot = torch.zeros(1).cuda(), torch.zeros(1).cuda()
for x, y in earlystopping:
x, y = x.cuda(), y.cuda()
D = dataloader.distanceToBorder(y)
tot += torch.sum(D)
z = net(x)
_, z = z.max(1)
cool = (z == y).float()
cool *= D
good += torch.sum(cool)
return 100.0 * good.cpu().numpy() / tot.cpu().numpy()
return 50.0 * cm[0][0] / (cm[0][0] + cm[1][0] +
cm[0][1]) + 50.0 * cm[1][1] / (
cm[1][1] + cm[1][0] + cm[0][1])
cmforlogging = []
cm = {}
with torch.no_grad():
for town in miniworld.towns:
print(town)
cm[town] = torch.zeros((2, 2)).cuda()
for i in range(miniworld.data[town].nbImages):
imageraw, label = miniworld.data[town].getImageAndLabel(i)
label = torch.Tensor(label).cuda()
distance = dataloader.distanceToBorder(label)
image = torch.Tensor(numpy.transpose(imageraw,
axes=(2, 0, 1))).unsqueeze(0)
h, w = image.shape[2], image.shape[3]
globalresize = torch.nn.AdaptiveAvgPool2d((h, w))
power2resize = torch.nn.AdaptiveAvgPool2d(
((h // 64) * 64, (w // 64) * 64))
image = power2resize(image)
pred = dataloader.largeforward(net, image)
pred = globalresize(pred)
_, pred = torch.max(pred[0], 0)
cm[town][0][0] += torch.sum(
# weights = torch.Tensor([1, miniworld.balance]).cuda()
# criterion = torch.nn.CrossEntropyLoss(weight=weights, reduction="none")
criterionbis = smp.losses.dice.DiceLoss(mode="multiclass")
optimizer = torch.optim.Adam(net.parameters(), lr=0.0001)
meanloss = collections.deque(maxlen=200)
nbepoch = 800
batchsize = 16
for epoch in range(nbepoch):
print("epoch=", epoch, "/", nbepoch)
XY = miniworld.getrandomtiles(10000, 128, batchsize)
for x, y in XY:
x, y = x.cuda(), y.cuda()
D = dataloader.distanceToBorder(y)
z = net(x)
if random.randint(0, 10) == 0:
weights = torch.Tensor([1, miniworld.balance]).cuda()
criterion = torch.nn.CrossEntropyLoss(weight=weights,
reduction="none")
else:
nb0, nb1 = torch.sum((y == 0).float()), torch.sum((y == 1).float())
weights = torch.Tensor([1, nb0 / nb1]).cuda()
criterion = torch.nn.CrossEntropyLoss(weight=weights,
reduction="none")
CE = criterion(z, y)
CE = torch.mean(CE * D)