示例#1
0
def test(epoch):
    # switch to evaluation mode
    net.eval()
    print('Extracting Gallery Feature...')
    start = time.time()
    ptr = 0
    gall_feat = np.zeros((ngall, 2048))
    gall_feat_att = np.zeros((ngall, 2048))
    with torch.no_grad():
        for batch_idx, (input, label) in enumerate(gall_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            feat, feat_att = net(input, input, test_mode[0])
            gall_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
            gall_feat_att[ptr:ptr + batch_num, :] = feat_att.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.time() - start))

    # switch to evaluation
    net.eval()
    print('Extracting Query Feature...')
    start = time.time()
    ptr = 0
    query_feat = np.zeros((nquery, 2048))
    query_feat_att = np.zeros((nquery, 2048))
    with torch.no_grad():
        for batch_idx, (input, label) in enumerate(query_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            feat, feat_att = net(input, input, test_mode[1])
            query_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
            query_feat_att[ptr:ptr + batch_num, :] = feat_att.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.time() - start))

    start = time.time()
    # compute the similarity
    distmat = np.matmul(query_feat, np.transpose(gall_feat))
    distmat_att = np.matmul(query_feat_att, np.transpose(gall_feat_att))

    # evaluation
    if dataset == 'regdb':
        cmc, mAP, mINP      = eval_regdb(-distmat, query_label, gall_label)
        cmc_att, mAP_att, mINP_att  = eval_regdb(-distmat_att, query_label, gall_label)
    elif dataset == 'sysu':
        cmc, mAP, mINP = eval_sysu(-distmat, query_label, gall_label, query_cam, gall_cam)
        cmc_att, mAP_att, mINP_att = eval_sysu(-distmat_att, query_label, gall_label, query_cam, gall_cam)
    print('Evaluation Time:\t {:.3f}'.format(time.time() - start))

    writer.add_scalar('rank1', cmc[0], epoch)
    writer.add_scalar('mAP', mAP, epoch)
    writer.add_scalar('mINP', mINP, epoch)
    writer.add_scalar('rank1_att', cmc_att[0], epoch)
    writer.add_scalar('mAP_att', mAP_att, epoch)
    writer.add_scalar('mINP_att', mINP_att, epoch)
    return cmc, mAP, mINP, cmc_att, mAP_att, mINP_att
示例#2
0
    def testPlus(epoch, rerank=False):
        net.eval()
        print('Extracting Gallery Feature...')
        start = time.time()
        gall_feat = []
        gall_feat2 = []
        gall_feat3 = []
        with torch.no_grad():
            for batch_idx, (input, label) in enumerate(tqdm(gall_loader)):
                input = Variable(input.cuda())
                feat_pool, feat_pool2, feat, feat2 = net(
                    input, input, test_mode[0])
                feat = feat.data
                gall_feat.append(feat)
        gall_feat = torch.cat(gall_feat, 0)
        print('Extracting Time:\t {:.3f}'.format(time.time() - start))
        net.eval()
        print('Extracting Query Feature...')
        start = time.time()

        query_feat = []
        with torch.no_grad():
            for batch_idx, (input, label) in enumerate(tqdm(query_loader)):
                input = Variable(input.cuda())
                feat_pool, feat_pool2, feat, feat2 = net(
                    input, input, test_mode[1])
                feat = feat.data
                query_feat.append(feat)
        query_feat = torch.cat(query_feat, 0)
        print('Extracting Time:\t {:.3f}'.format(time.time() - start))

        start = time.time()
        if rerank:
            print("==> reranking ....")
            distmat = reranking(query_feat, gall_feat)
            cmc, mAP = eval_sysu(distmat, query_label, gall_label, query_cam,
                                 gall_cam)
        else:
            distmat = np.matmul(query_feat, np.transpose(gall_feat))
            cmc, mAP = eval_sysu(-distmat, query_label, gall_label, query_cam,
                                 gall_cam)
            print('Evaluation Time:\t {:.3f}'.format(time.time() - start))
        return cmc, mAP
示例#3
0
def test(epoch):
    # switch to evaluation mode
    l2norm = Normalize()
    net.eval()
    print('Extracting Gallery Feature...')
    start = time.clock()
    ptr = 0
    gall_feat = np.zeros((ngall, final_dim + 1024))
    with torch.no_grad():
        for batch_idx, (input, label) in enumerate(gall_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            _, _, feat, _, _, feat3 = net(input)
            feat = l2norm(feat)
            feat3 = l2norm(feat3)
            feat = torch.cat((feat, feat3), dim=1)
            gall_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.clock() - start))

    # switch to evaluation mode
    net.eval()
    print('Extracting Query Feature...')
    start = time.clock()
    ptr = 0
    query_feat = np.zeros((nquery, final_dim + 1024))
    with torch.no_grad():
        for batch_idx, (input, label) in enumerate(query_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            _, _, feat, _, _, feat3 = net(input)
            feat = l2norm(feat)
            feat3 = l2norm(feat3)
            feat = torch.cat((feat, feat3), dim=1)
            query_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.clock() - start))

    start = time.clock()
    distmat = np.matmul(query_feat, np.transpose(gall_feat))

    # evaluation
    if dataset == 'regdb':
        cmc, mAP = eval_regdb(-distmat, query_label, gall_label)
    elif dataset == 'sysu':
        cmc, mAP = eval_sysu(-distmat, query_label, gall_label, query_cam,
                             gall_cam)
    print('Evaluation Time:\t {:.3f}'.format(time.clock() - start))
    return cmc, mAP
示例#4
0
def test(epoch):   
    # switch to evaluation mode
    net.eval()
    print ('Extracting Gallery Feature...')
    start = time.time()
    ptr = 0
    gall_feat = np.zeros((ngall, 2048*7))
    with torch.no_grad():
        for batch_idx, (input, label ) in enumerate(gall_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            feat,feat_part = net(input, input, test_mode[0])
            feat_temp = torch.cat(feat_part,1)
            feat_temp = torch.cat((feat_temp,feat),1)
            gall_feat[ptr:ptr+batch_num,: ] = feat_temp.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.time()-start))   

    # switch to evaluation mode
    net.eval()
    print ('Extracting Query Feature...')
    start = time.time()
    ptr = 0
    query_feat = np.zeros((nquery, 2048*7))
    with torch.no_grad():
        for batch_idx, (input, label ) in enumerate(query_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            feat_part = net(input, input, test_mode[1])
            feat_temp = torch.cat(feat_part,1)
            feat_temp = torch.cat((feat_temp,feat),1)
            query_feat[ptr:ptr+batch_num,: ] = feat_temp.detach().cpu().numpy()
            ptr = ptr + batch_num         
    print('Extracting Time:\t {:.3f}'.format(time.time()-start))
    
    start = time.time()
    # compute the similarity
    gall_feat = 1.*gall_feat/np.repeat(np.linalg.norm(gall_feat,2,1,True),gall_feat.shape[1],1)
    query_feat = 1.*query_feat/np.repeat(np.linalg.norm(query_feat,2,1,True),query_feat.shape[1],1)
    distmat  = np.matmul(query_feat, np.transpose(gall_feat))
    
    # evaluation
    if dataset =='regdb':
        cmc, mAP = eval_regdb(-distmat, query_label, gall_label)
    elif dataset =='sysu':
        cmc, mAP = eval_sysu(-distmat, query_label, gall_label, query_cam, gall_cam)
    print('Evaluation Time:\t {:.3f}'.format(time.time()-start))
    return cmc, mAP
示例#5
0
文件: train.py 项目: kajal15003/SDL
def test(epoch):
    # switch to evaluation mode
    net.eval()
    print('Extracting Gallery Feature...')
    start = time.time()
    ptr = 0
    gall_feat = np.zeros((ngall, args.low_dim))
    with torch.no_grad():
        for batch_idx, (input, label) in enumerate(gall_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            feat_pool, feat, feat_vis, feat_inf, out_u, feat_u, p_v, p_i = net(
                input, input, test_mode[0])
            gall_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.time() - start))

    # switch to evaluation mode
    net.eval()
    print('Extracting Query Feature...')
    start = time.time()
    ptr = 0
    query_feat = np.zeros((nquery, args.low_dim))
    with torch.no_grad():
        for batch_idx, (input, label) in enumerate(query_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            feat_pool, feat, feat_vis, feat_inf, out_u, feat_u, p_v, p_i = net(
                input, input, test_mode[1])
            query_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.time() - start))

    start = time.time()
    # compute the similarity
    distmat = np.matmul(query_feat, np.transpose(gall_feat))

    # evaluation
    if dataset == 'regdb':
        cmc, mAP = eval_regdb(-distmat, query_label, gall_label)
    elif dataset == 'sysu':
        cmc, mAP = eval_sysu(-distmat, query_label, gall_label, query_cam,
                             gall_cam)
    print('Evaluation Time:\t {:.3f}'.format(time.time() - start))
    return cmc, mAP
示例#6
0
文件: test.py 项目: CodeLHY/P-reID
        gall_feat, gall_feat_pool = extract_gall_feat(trial_gall_loader)

        gall_feat = 1. * gall_feat / np.repeat(
            np.linalg.norm(gall_feat, 2, 1, True), gall_feat.shape[1], 1)
        gall_feat_pool = 1. * gall_feat_pool / np.repeat(
            np.linalg.norm(gall_feat_pool, 2, 1, True),
            gall_feat_pool.shape[1], 1)
        query_feat = 1. * query_feat / np.repeat(
            np.linalg.norm(query_feat, 2, 1, True), query_feat.shape[1], 1)
        query_feat_pool = 1. * query_feat_pool / np.repeat(
            np.linalg.norm(query_feat_pool, 2, 1, True),
            query_feat_pool.shape[1], 1)
        # fc feature
        distmat = np.matmul(query_feat, np.transpose(gall_feat))
        cmc, mAP = eval_sysu(-distmat, query_label, gall_label, query_cam,
                             gall_cam)

        # pool5 feature
        distmat_pool = np.matmul(query_feat_pool, np.transpose(gall_feat_pool))
        cmc_pool, mAP_pool = eval_sysu(-distmat_pool, query_label, gall_label,
                                       query_cam, gall_cam)
        if trial == 0:
            all_cmc = cmc
            all_mAP = mAP
            all_cmc_pool = cmc_pool
            all_mAP_pool = mAP_pool
        else:
            all_cmc = all_cmc + cmc
            all_mAP = all_mAP + mAP
            all_cmc_pool = all_cmc_pool + cmc_pool
            all_mAP_pool = all_mAP_pool + mAP_pool
示例#7
0
def test(epoch):
    # switch to evaluation mode
    net.eval()
    print('Extracting Gallery Feature...')
    start = time.time()
    ptr = 0
    if args.pcb == 'on':
        feat_dim = args.num_strips * args.local_feat_dim
    else:
        feat_dim = 2048
    gall_feat = np.zeros((ngall, feat_dim))
    gall_feat_att = np.zeros((ngall, feat_dim))
    with torch.no_grad():
        for batch_idx, (input, label) in enumerate(gall_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            if args.pcb == 'on':
                feat = net(input, input, test_mode[0])
                gall_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
            else:
                feat, feat_att = net(input, input, test_mode[0])
                gall_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
                gall_feat_att[ptr:ptr +
                              batch_num, :] = feat_att.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.time() - start))

    # switch to evaluation
    net.eval()
    print('Extracting Query Feature...')
    start = time.time()
    ptr = 0

    query_feat = np.zeros((nquery, feat_dim))
    query_feat_att = np.zeros((nquery, feat_dim))
    with torch.no_grad():
        for batch_idx, (input, label) in enumerate(query_loader):
            batch_num = input.size(0)
            input = Variable(input.cuda())
            if args.pcb == 'on':
                feat = net(input, input, test_mode[1])
                query_feat[ptr:ptr +
                           batch_num, :] = feat.detach().cpu().numpy()
            else:
                feat, feat_att = net(input, input, test_mode[1])
                query_feat[ptr:ptr +
                           batch_num, :] = feat.detach().cpu().numpy()
                query_feat_att[ptr:ptr +
                               batch_num, :] = feat_att.detach().cpu().numpy()
            ptr = ptr + batch_num
    print('Extracting Time:\t {:.3f}'.format(time.time() - start))

    start = time.time()

    if args.re_rank == 'random_walk':
        distmat = random_walk(query_feat, gall_feat)
        if args.pcb == 'off':
            distmat_att = random_walk(query_feat_att, gall_feat_att)
    elif args.re_rank == 'k_reciprocal':
        distmat = k_reciprocal(query_feat, gall_feat)
        if args.pcb == 'off':
            distmat_att = k_reciprocal(query_feat_att, gall_feat_att)
    elif args.re_rank == 'no':
        # compute the similarity
        distmat = -np.matmul(query_feat, np.transpose(gall_feat))
        if args.pcb == 'off':
            distmat_att = -np.matmul(query_feat_att,
                                     np.transpose(gall_feat_att))

    # evaluation
    if dataset == 'regdb':
        cmc, mAP, mINP = eval_regdb(distmat, query_label, gall_label)
        if args.pcb == 'off':
            cmc_att, mAP_att, mINP_att = eval_regdb(distmat_att, query_label,
                                                    gall_label)
    elif dataset == 'sysu':
        cmc, mAP, mINP = eval_sysu(distmat, query_label, gall_label, query_cam,
                                   gall_cam)
        if args.pcb == 'off':
            cmc_att, mAP_att, mINP_att = eval_sysu(distmat_att, query_label,
                                                   gall_label, query_cam,
                                                   gall_cam)
    print('Evaluation Time:\t {:.3f}'.format(time.time() - start))

    writer.add_scalar('rank1', cmc[0], epoch)
    writer.add_scalar('mAP', mAP, epoch)
    writer.add_scalar('mINP', mINP, epoch)
    if args.pcb == 'off':
        writer.add_scalar('rank1_att', cmc_att[0], epoch)
        writer.add_scalar('mAP_att', mAP_att, epoch)
        writer.add_scalar('mINP_att', mINP_att, epoch)

        return cmc, mAP, mINP, cmc_att, mAP_att, mINP_att
    else:
        return cmc, mAP, mINP
示例#8
0
    def test(net, epoch):
        # switch to evaluation mode
        net.eval()
        print('Extracting Gallery Feature...')
        start = time.time()
        ptr = 0
        gall_feat = np.zeros((ngall, args.low_dim))  #args.low_dim
        label_g = []
        with torch.no_grad():
            for batch_idx, (input, label) in enumerate(gall_loader):
                batch_num = input.size(0)
                input = Variable(input.cuda())
                feat_pool, feat = net(input, input, test_mode[0])
                label_g.append(label)
                gall_feat[ptr:ptr + batch_num, :] = feat.detach().cpu().numpy()
                ptr = ptr + batch_num
        print('Extracting Time:\t {:.3f}'.format(time.time() - start))

        # switch to evaluation mode
        net.eval()
        print('Extracting Query Feature...')
        start = time.time()
        ptr = 0
        query_feat = np.zeros((nquery, args.low_dim))
        label_q = []
        with torch.no_grad():
            for batch_idx, (input, label) in enumerate(query_loader):
                batch_num = input.size(0)
                input = Variable(input.cuda())
                feat_pool, feat = net(input, input, test_mode[1])

                query_feat[ptr:ptr +
                           batch_num, :] = feat.detach().cpu().numpy()
                label_q.append(label)
                ptr = ptr + batch_num
        print('Extracting Time:\t {:.3f}'.format(time.time() - start))

        start = time.time()
        # compute the similarity
        distmat = np.matmul(query_feat, np.transpose(gall_feat))

        # output=np.concatenate((query_feat,gall_feat),0)
        # labels=label_q+label_g
        # figure = draw_cluster(output, labels, len(label_q),len(label_g))
        # #
        # plt.savefig('/home/zhangc/projects/cross_modality_V/BDTR_modal_loss_cbam_debug/image/cluster/' + str(
        #     epoch) + '_test_'+suffix_id+'.jpg')
        # plt.show()
        # plt.pause(1)
        # plt.close()

        # evaluation
        if dataset == 'regdb':
            cmc, mAP = eval_regdb(-distmat, query_label, gall_label)
        elif dataset == 'sysu':
            cmc, mAP = eval_sysu(-distmat, query_label, gall_label, query_cam,
                                 gall_cam)
        print('Evaluation Time:\t {:.3f}'.format(time.time() - start))

        # uni_que = np.unique(query_label)
        # n_q, n_g = 0, 0
        # output = []
        # labels = []
        # for i in range(30):
        #     label_id = uni_que[randrange(0, len(uni_que))]
        #     index_q = [i for i, a in enumerate(query_label) if a == label_id]
        #     index_g = [i for i, a in enumerate(gall_label) if a == label_id]
        #     output.extend(np.concatenate((query_feat[index_q, :], gall_feat[index_g, :]), 0))
        #     tmp_q = query_label[index_q]
        #     tmp_g = gall_label[index_g]
        #     n_q += len(tmp_q)
        #     n_g += len(tmp_g)
        #     labels.extend(np.concatenate((tmp_q, tmp_g), 0))
        #
        # figure = draw_cluster(output, labels, n_q, n_g)
        # #
        # suffix_id = 'DEBUG_30'
        # plt.savefig(
        #     '/home/zhangc/projects/cross_modality_V/BDTR_modal_loss_cbam_debug/image/cluster/'  + '_train_' + suffix_id + '.jpg')
        # plt.show()
        # plt.pause(1)
        # plt.close()
        return cmc, mAP