code of paper scene parsing with point-based distance metric learning

[ywh187]

Hello, in your paper you mentioned that you implemented the paper "Weakly supervised scene parsing with point-based distance metric learning" . Could you please post this part of the code? thank you very much!

[fcdl94]

Hello.

This is the loss I used for the PDML method:

class PointDistanceMetricLoss(nn.Module):
    def __init__(self, alpha=0.8, beta=1, m=20):
        super().__init__()
        self.alpha = alpha
        self.beta = beta
        self.m = m
        self.pos_loss = lambda x, y: self.alpha*torch.norm(x-y)
        self.neg_loss = lambda x, yp, yn: self.beta * max(torch.norm(x-yp) - torch.norm(x-yn) + self.m,
                                                          torch.tensor(0., device=x.device))
        self.loss = lambda x, yp, yn: self.pos_loss(x, yp) + self.neg_loss(x, yp, yn)

        self.crop_size = 0
        self.out_stride = 0

    def convert_index(self, i):
        new_i = (i // self.crop_size + i % self.crop_size) // self.out_stride
        return new_i.long()

    def forward(self, features, targets):
        loss = 0.
        count = 0
        ci = self.convert_index
        self.crop_size = targets.shape[-1]
        self.out_stride = self.crop_size / features.shape[-1]
        bs = len(features)
        f_size = features.shape[1]
        for i in range(bs):  # for each image
            tarx = targets[i].view(-1)  # HW
            x = features[i].view(f_size, -1)  # FxHW
            em = ((tarx != 0)*(tarx != 255)).nonzero()  # list of points non 0 or 255

            for j in range(bs):
                if i != j:
                    tary = targets[j].view(-1)  # HW
                    y = features[j].view(f_size, -1)  # FxHW
                    en = ((tary != 0)*(tary != 255)).nonzero()  # list of points non 0 or 255
                    for pi in em:
                        epos = []
                        eneg = []
                        for pj in en:
                            if tarx[pi] == tary[pj]:
                                epos.append(pj)
                            else:
                                eneg.append(pj)
                        while len(eneg) > 0 and len(epos) > 0:
                            ppos = epos.pop(random.randint(0, len(epos)-1))
                            pneg = eneg.pop(random.randint(0, len(eneg)-1))
                            loss += self.loss(x[:, ci(pi)], y[:, ci(ppos)], y[:, ci(pneg)])
                            count += 1
        if count > 0:
            return loss
        else:
            return 0.