Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use is_pos method in Airtest

Best Python code snippet using Airtest

triplet_loss.py

Source:triplet_loss.py

1# encoding: utf-82"""3@author:  liaoxingyu4@contact: sherlockliao01@gmail.com5"""6import torch7import torch.nn.functional as F8from fastreid.utils import comm9from fastreid.layers import GatherLayer10from .utils import concat_all_gather, euclidean_dist, normalize11def softmax_weights(dist, mask):12    max_v = torch.max(dist * mask, dim=1, keepdim=True)[0]13    diff = dist - max_v14    Z = torch.sum(torch.exp(diff) * mask, dim=1, keepdim=True) + 1e-6  # avoid division by zero15    W = torch.exp(diff) * mask / Z16    return W17def hard_example_mining(dist_mat, is_pos, is_neg):18    """For each anchor, find the hardest positive and negative sample.19    Args:20      dist_mat: pair wise distance between samples, shape [N, M]21      is_pos: positive index with shape [N, M]22      is_neg: negative index with shape [N, M]23    Returns:24      dist_ap: pytorch Variable, distance(anchor, positive); shape [N]25      dist_an: pytorch Variable, distance(anchor, negative); shape [N]26      p_inds: pytorch LongTensor, with shape [N];27        indices of selected hard positive samples; 0 <= p_inds[i] <= N - 128      n_inds: pytorch LongTensor, with shape [N];29        indices of selected hard negative samples; 0 <= n_inds[i] <= N - 130    NOTE: Only consider the case in which all labels have same num of samples,31      thus we can cope with all anchors in parallel.32    """33    assert len(dist_mat.size()) == 234    N = dist_mat.size(0)35    # `dist_ap` means distance(anchor, positive)36    # both `dist_ap` and `relative_p_inds` with shape [N, 1]37    dist_ap, relative_p_inds = torch.max(38        dist_mat[is_pos].contiguous().view(N, -1), 1, keepdim=True)39    # `dist_an` means distance(anchor, negative)40    # both `dist_an` and `relative_n_inds` with shape [N, 1]41    dist_an, relative_n_inds = torch.min(42        dist_mat[is_neg].contiguous().view(N, -1), 1, keepdim=True)43    # shape [N]44    dist_ap = dist_ap.squeeze(1)45    dist_an = dist_an.squeeze(1)46    return dist_ap, dist_an47def weighted_example_mining(dist_mat, is_pos, is_neg):48    """For each anchor, find the weighted positive and negative sample.49    Args:50      dist_mat: pytorch Variable, pair wise distance between samples, shape [N, N]51      is_pos:52      is_neg:53    Returns:54      dist_ap: pytorch Variable, distance(anchor, positive); shape [N]55      dist_an: pytorch Variable, distance(anchor, negative); shape [N]56    """57    assert len(dist_mat.size()) == 258    is_pos = is_pos.float()59    is_neg = is_neg.float()60    dist_ap = dist_mat * is_pos61    dist_an = dist_mat * is_neg62    weights_ap = softmax_weights(dist_ap, is_pos)63    weights_an = softmax_weights(-dist_an, is_neg)64    dist_ap = torch.sum(dist_ap * weights_ap, dim=1)65    dist_an = torch.sum(dist_an * weights_an, dim=1)66    return dist_ap, dist_an67def triplet_loss(embedding, targets, margin, norm_feat, hard_mining):68    r"""Modified from Tong Xiao's open-reid (https://github.com/Cysu/open-reid).69    Related Triplet Loss theory can be found in paper 'In Defense of the Triplet70    Loss for Person Re-Identification'."""71    if norm_feat: embedding = normalize(embedding, axis=-1)72    # For distributed training, gather all features from different process.73    if comm.get_world_size() > 1:74        all_embedding = torch.cat(GatherLayer.apply(embedding), dim=0)75        all_targets = concat_all_gather(targets)76    else:77        all_embedding = embedding78        all_targets = targets79    dist_mat = euclidean_dist(all_embedding, all_embedding)80    N, N = dist_mat.size()81    is_pos = all_targets.view(N, 1).expand(N, N).eq(all_targets.view(N, 1).expand(N, N).t())82    is_neg = all_targets.view(N, 1).expand(N, N).ne(all_targets.view(N, 1).expand(N, N).t())83    if hard_mining:84        dist_ap, dist_an = hard_example_mining(dist_mat, is_pos, is_neg)85    else:86        dist_ap, dist_an = weighted_example_mining(dist_mat, is_pos, is_neg)87    y = dist_an.new().resize_as_(dist_an).fill_(1)88    if margin > 0:89        loss = F.margin_ranking_loss(dist_an, dist_ap, y, margin=margin)90    else:91        loss = F.soft_margin_loss(dist_an - dist_ap, y)92        # fmt: off93        if loss == float('Inf'): loss = F.margin_ranking_loss(dist_an, dist_ap, y, margin=0.3)94        # fmt: on...

pairwise.py

Source:pairwise.py

1import torch2from torch import nn3from torch.nn import functional as F4class CosFacePairLoss(nn.Module):5    def __init__(self, s=30, m=0.50):6        super(CosFacePairLoss, self).__init__()7        self.s = s8        self.m = m9    def forward(self, embedding, targets):10        embedding = F.normalize(embedding, p=2, dim=1)11        # if torch.distributed.is_initialized():12        #     embedding = AllGather(embedding)13        #     targets = AllGather(targets)14        dist_mat = torch.matmul(embedding, embedding.t())15        N = dist_mat.size(0)16        is_pos = targets.view(N, 1).expand(N, N).eq(targets.view(N, 1).expand(N, N).t()).float()17        is_neg = targets.view(N, 1).expand(N, N).ne(targets.view(N, 1).expand(N, N).t()).float()18        # Mask scores related to itself19        is_pos = is_pos - torch.eye(N, N, device=is_pos.device)20        s_p = dist_mat * is_pos21        s_n = dist_mat * is_neg22        logit_p = -self.s * s_p + (-99999999.0) * (1 - is_pos)23        logit_n = self.s * (s_n + self.m) + (-99999999.0) * (1 - is_neg)24        loss = F.softplus(torch.logsumexp(logit_p, dim=1) + torch.logsumexp(logit_n, dim=1)).mean()25        return loss26class CosFacePairLoss_v2(nn.Module):27    def __init__(self, s=30, m_max=0.6, m_min=0.2, m=0):28        super(CosFacePairLoss_v2, self).__init__()29        self.s = s30        self.m_max = m_max31        self.m_min = m_min32    def forward(self, embedding, targets):33        embedding = F.normalize(embedding, p=2, dim=1)34        # if torch.distributed.is_initialized():35        #     embedding = AllGather(embedding)36        #     targets = AllGather(targets)37        dist_mat = torch.matmul(embedding, embedding.t())38        N = dist_mat.size(0)39        mask = is_pos = targets.view(N, 1).expand(N, N).eq(targets.view(N, 1).expand(N, N).t()).float()40        is_neg = targets.view(N, 1).expand(N, N).ne(targets.view(N, 1).expand(N, N).t()).float()41        # Mask scores related to itself42        is_pos = is_pos - torch.eye(N, N, device=is_pos.device)43        p_simi = (dist_mat * is_pos).sum(1) / is_pos.sum(1)44        p_simi = p_simi.mean()45        m = (self.m_max - self.m_min) * p_simi + self.m_min46        mask_hard_neg = ((p_simi - m) < dist_mat) * (1 - mask)47        scale_matrix = self.s * (1 - mask_hard_neg) + self.s * mask_hard_neg * (p_simi + self.m_max - self.m_min)48        s_p = dist_mat * is_pos49        s_n = dist_mat * is_neg50        logit_p = -scale_matrix * s_p + (-99999999.0) * (1 - is_pos)51        logit_n = scale_matrix * (s_n + m) + (-99999999.0) * (1 - is_neg)52        loss = F.softplus(torch.logsumexp(logit_p, dim=1) + torch.logsumexp(logit_n, dim=1)).mean()53        return loss54    55class CirclePairLoss(nn.Module):56    def __init__(self, s=30, m=0.30):57        super(CirclePairLoss, self).__init__()58        self.s = s59        self.m = m60    def forward(self, embedding, targets):61        embedding = F.normalize(embedding, p=2, dim=1)62        # if torch.distributed.is_initialized():63        #     embedding = AllGather(embedding)64        #     targets = AllGather(targets)65        dist_mat = torch.matmul(embedding, embedding.t())66        N = dist_mat.size(0)67        is_pos = targets.view(N, 1).expand(N, N).eq(targets.view(N, 1).expand(N, N).t()).float()68        is_neg = targets.view(N, 1).expand(N, N).ne(targets.view(N, 1).expand(N, N).t()).float()69        # Mask scores related to itself70        is_pos = is_pos - torch.eye(N, N, device=is_pos.device)71        s_p = dist_mat * is_pos72        s_n = dist_mat * is_neg73        alpha_p = torch.clamp_min(-s_p.detach() + 1 + self.m, min=0.)74        alpha_n = torch.clamp_min(s_n.detach() + self.m, min=0.)75        delta_p = 1 - self.m76        delta_n = self.m77        logit_p = - self.s * alpha_p * (s_p - delta_p) + (-99999999.) * (1 - is_pos)78        logit_n = self.s * alpha_n * (s_n - delta_n) + (-99999999.) * (1 - is_neg)79        loss = F.softplus(torch.logsumexp(logit_p, dim=1) + torch.logsumexp(logit_n, dim=1)).mean()...

multisoftmax.py

Source:multisoftmax.py

1import torch2from torch import nn3import torch.nn.functional as F4eps = 1e-75class NCECriterion(nn.Module):6    """7    Eq. (12): L_{NCE}8    """9    def __init__(self, n_data):10        super(NCECriterion, self).__init__()11        self.n_data = n_data12    def forward(self, x):13        bsz = x.shape[0]14        m = x.size(1) - 115        # noise distribution16        Pn = 1 / float(self.n_data)17        # loss for positive pair18        P_pos = x.select(1, 0)19        log_D1 = torch.div(P_pos, P_pos.add(m * Pn + eps)).log_()20        # loss for K negative pair21        P_neg = x.narrow(1, 1, m)22        log_D0 = torch.div(P_neg.clone().fill_(m * Pn), P_neg.add(m * Pn + eps)).log_()23        loss = - (log_D1.sum(0) + log_D0.view(-1, 1).sum(0)) / bsz24        return loss25class NCESoftmaxLoss(nn.Module):26    """Softmax cross-entropy loss (a.k.a., info-NCE loss in CPC paper)"""27    def __init__(self):28        super(NCESoftmaxLoss, self).__init__()29        self.criterion = nn.CrossEntropyLoss()30    def forward(self, x):31        bsz = x.shape[0]32        x = x.squeeze()33        label = torch.zeros([bsz]).cuda().long()34        loss = self.criterion(x, label)35        return loss36class MultiSoftmaxLoss(nn.Module):37    def __init__(self):38        super().__init__()39        # self.criterion = nn.KLDivLoss(reduction='batchmean')40        self.criterion = nn.CrossEntropyLoss()41        # self.criterion = nn.NLLLoss(reduction='mean')42    def forward(self, x, is_pos):43        bsz = x.shape[0]44        # ce_loss = self.criterion(x, torch.zeros([bsz]).cuda().long())45        x = x.squeeze()46        x = torch.exp(x)47        is_pos = torch.cat((torch.ones([bsz, 1], dtype=torch.long).cuda(), is_pos.long()), dim=1)48        is_neg = (1 - is_pos).float()49        neg_div = (x * is_neg).sum(dim=1, keepdim=True)50        x_logit = x / (x + neg_div)51        x_logit = -torch.log(x_logit)52        x_mask = x_logit * is_pos.float()53        num_pos = is_pos.sum(dim=1, keepdim=True).float()54        x_mask = x_mask / num_pos55        loss = x_mask.sum(dim=1).mean(dim=0)56        return loss57        # loss = 058        # for i in range(bsz):59        #     tmp_loss = 060        #     pos_inds = torch.where(is_pos[i] == 1)[0].tolist()61        #     num_pos = len(pos_inds)62        #     for j in pos_inds:63        #         tmp_loss -= torch.log(x[i, j] / (neg_div[i][0] + x[i, j]))64        #     loss += (tmp_loss / num_pos)65        # loss = loss / bsz66        #67        # print(loss)68        # print(fast_loss)69        # from ipdb import set_trace; set_trace()70        # print(ce_loss)71        # print(loss)72    # def forward(self, x, is_pos):73    #     is_pos = is_pos.float()74    #     bsz = x.shape[0]75    #     x = x.squeeze()76    #77    #     label = torch.zeros([bsz]).cuda().long()78    #     # loss = self.criterion1(x, ce_label)79    #80    #     # from ipdb import set_trace; set_trace()81    #     # is_neg = 1 - is_pos[:, 1:]82    #     x = F.softmax(x, dim=1)83    #     x = (x * is_pos).sum(dim=1, keepdim=True)84    #     # neg_logit = (x * is_neg)85    #     # x = torch.cat((pos_logit, x[:, 1:]), dim=1)  # [bsz, 16385]86    #     # x = torch.log(x)87    #88    #     loss = self.criterion(x.log(), label)89    #     return loss90        # x = F.softmax(x, dim=1)91        # label = torch.cat((torch.ones([bsz, 1], dtype=torch.float32).cuda(), is_pos), dim=1)  # (bsz, dim)92        # label = F.softmax(label, dim=1)93        # label = label / label.sum(dim=1, keepdim=True)94        # loss = torch.sum(x * torch.log(1e-9 + x / (label + 1e-9)), dim=1).mean(dim=0)95        # loss = torch.sum(x * (1e-9 + torch.log(x) - torch.log(label + 1e-9)), dim=1).mean(dim=0)96        # from ipdb import set_trace; set_trace()97        # loss = self.criterion(x, label)...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.