2. 程式人生 > >行人重識別(ReID) ——基於MGN-pytorch進行視覺化展示

行人重識別(ReID) ——基於MGN-pytorch進行視覺化展示

阿新 • • 發佈：2018-12-24

模型訓練，修改demo.sh，將 --datadir修改已下載的Market1501資料集地址，將修改CUDA_VISIBLE_DEVICES=2,3自己的GPU裝置ID，將修改--nGPU自己的GPU數量。

部分demo.sh示例：

#mAP: 0.9204 rank1: 0.9469 rank3: 0.9664 rank5: 0.9715 rank10: 0.9780 (Best: 0.9204 @epoch 4)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 40 --epochs 160 --decay_type step_120_140 --loss 1*CrossEntropy+2*Triplet --margin 0.3 --re_rank --random_erasing --save MGN_adam --nGPU 2  --lr 2e-4 --optimizer ADAM

CUDA_VISIBLE_DEVICES=0 python main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 8 --batchtest 16 --test_every 40 --epochs 160 --decay_type step_120_140 --loss 1*CrossEntropy+2*Triplet --margin 0.3 --re_rank --random_erasing --save MGN_adam --nGPU 1  --lr 2e-4 --optimizer ADAM --save_models

CUDA_VISIBLE_DEVICES=0 python main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 8 --batchtest 8 --test_every 10 --epochs 10 --decay_type step_120_140 --loss 1*CrossEntropy+2*Triplet --margin 0.3 --re_rank --random_erasing --save MGN_adam --nGPU 1  --lr 2e-4 --optimizer ADAM --test_only --resume -1 --load MGN_adam


#mAP: 0.9094 rank1: 0.9388 rank3: 0.9596 rank5: 0.9659 rank10: 0.9748 (Best: 0.9094 @epoch 4)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 40 --epochs 160 --decay_type step_120_140 --loss 1*CrossEntropy+1*Triplet --margin 0.3 --re_rank --random_erasing --save MGN_adam_1 --nGPU 2  --lr 1e-4 --optimizer ADAM

#mAP: 0.9217 rank1: 0.9460 rank3: 0.9653 rank5: 0.9706 rank10: 0.9801 (Best: 0.9217 @epoch 4)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 40 --epochs 160 --decay_type step_120_140 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --re_rank --random_erasing --save MGN_adam_margin_1.2 --nGPU 2  --lr 2e-4 --optimizer ADAM

#mAP: 0.8986 rank1: 0.9356 rank3: 0.9567 rank5: 0.9620 rank10: 0.9727 (Best: 0.8986 @epoch 4)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 40 --epochs 160 --decay_type step_120_140 --loss 1*CrossEntropy+2*Triplet --margin 0.3 --re_rank --random_erasing --save MGN_adamax --nGPU 2  --lr 2e-4 --optimizer ADAMAX

#mAP: 0.5494 rank1: 0.7058 rank3: 0.7696 rank5: 0.8023 rank10: 0.8432 (Best: 0.5494 @epoch 4)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 40 --epochs 160 --decay_type step_80_120 --loss 1*CrossEntropy+1*Triplet --margin 0.3 --re_rank --random_erasing --save MGN_sgd --nGPU 2 --lr 1e-2 --optimizer SGD 

#mAP: 0.8480 rank1: 0.9008 rank3: 0.9317 rank5: 0.9436 rank10: 0.9555 (Best: 0.8480 @epoch 3)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 40 --epochs 120 --decay_type step_60_80 --loss 1*CrossEntropy+1*Triplet --margin 0.3 --re_rank --random_erasing --save MGN_sgd_1 --nGPU 2 --lr 1e-2 --optimizer SGD 

#mAP: 0.8455 rank1: 0.9032 rank3: 0.9350 rank5: 0.9433 rank10: 0.9537 (Best: 0.8455 @epoch 3)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 40 --epochs 120 --decay_type step_60_80 --loss 1*CrossEntropy+1*Triplet --margin 1.2 --re_rank --random_erasing --save MGN_sgd_2 --nGPU 2 --lr 1e-2 --optimizer SGD 

#mAP: 0.8979 rank1: 0.9376 rank3: 0.9569 rank5: 0.9623 rank10: 0.9745 (Best: 0.8979 @epoch 200)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 50 --epochs 200 --decay_type step_130_170 --loss 1*CrossEntropy+1*Triplet --margin 1.2 --re_rank --random_erasing --save sgd_1 --nGPU 2 --lr 1e-2 --optimizer SGD --reset

#mAP: 0.8053 rank1: 0.9228 rank3: 0.9581 rank5: 0.9676 rank10: 0.9804 (Best: 0.8054 @epoch 190)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --reset --batchid 16 --batchtest 32 --test_every 10 --epochs 200 --decay_type step_240_250 --loss 1*CrossEntropy+1*Triplet --margin 1.2 --save sgd_2 --nGPU 2 --lr 1e-2 --optimizer SGD --save_models --random_erasing --reset

#mAP: 0.8251 rank1: 0.9353 rank3: 0.9679 rank5: 0.9783 rank10: 0.9866 (Best: 0.8251 @epoch 200)
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --reset --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 10 --epochs 200 --decay_type step_240_250 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --random_erasing --save adam_1 --nGPU 2  --lr 2e-4 --optimizer ADAM --save_models

#mAP: 0.9097 rank1: 0.9442 rank3: 0.9614 rank5: 0.9679 rank10: 0.9751
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 100 --epochs 300 --decay_type step_250_290 --loss 1*CrossEntropy+1*Triplet --margin 1.2 --save sgd_3 --nGPU 2 --lr 1e-2 --optimizer SGD --save_models --random_erasing --reset --re_rank

#mAP: 0.9353 rank1: 0.9534 rank3: 0.9706 rank5: 0.9768 rank10: 0.9849
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 100 --epochs 300 --decay_type step_250_290 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --save adam_2 --nGPU 2  --lr 2e-4 --optimizer ADAM --save_models --random_erasing --reset --re_rank

#mAP: 0.9174 rank1: 0.9433 rank3: 0.9617 rank5: 0.9679 rank10: 0.9754
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 20 --epochs 300 --decay_type step_250_290 --loss 1*CrossEntropy+1*Triplet --margin 1.2 --save sgd_3 --nGPU 2 --lr 1e-2 --optimizer SGD --random_erasing --reset --re_rank --nesterov

#mAP: 0.9376 rank1: 0.9558 rank3: 0.9712 rank5: 0.9765 rank10: 0.9816
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 100 --epochs 300 --decay_type step_250_290 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --save adam_3 --nGPU 2  --lr 2e-4 --optimizer ADAM --random_erasing --reset --re_rank --amsgrad

CUDA_VISIBLE_DEVICES=0 python main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 8 --batchtest 32 --test_every 100 --epochs 300 --decay_type step_250_290 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --save adam_3 --nGPU 1  --lr 2e-4 --optimizer ADAM --random_erasing --reset --re_rank --amsgrad

CUDA_VISIBLE_DEVICES=0 python main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 20 --epochs 300 --decay_type step_250_290 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --save adam_3 --nGPU 1  --lr 2e-4 --optimizer ADAM --random_erasing --re_rank --load adam_3 --test_only --resume -1


#mAP: 0.9323 rank1: 0.9513 rank3: 0.9700 rank5: 0.9745 rank10: 0.9813
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 100 --epochs 300 --decay_type step_250_290 --loss 1*CrossEntropy+2*Triplet --margin 0.3 --save adam_1 --nGPU 2  --lr 2e-4 --optimizer ADAM --random_erasing --reset --re_rank --amsgrad

#mAP: 0.9270 rank1: 0.9510 rank3: 0.9691 rank5: 0.9751 rank10: 0.9810
#CUDA_VISIBLE_DEVICES=2,3 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 50 --epochs 500 --decay_type step_300_420 --loss 1*CrossEntropy+1*Triplet --margin 1.2 --pool avg --save sgd_1 --nGPU 2 --lr 1e-2 --optimizer SGD --random_erasing --reset --re_rank --nesterov

#0.9383 rank1: 0.9578 rank3: 0.9721 rank5: 0.9783 rank10: 0.9843 (Best: 0.9383 @epoch 400)
#CUDA_VISIBLE_DEVICES=1 python3 main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 50 --epochs 400 --decay_type step_320_380 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --save adam_1 --nGPU 1  --lr 2e-4 --optimizer ADAM --random_erasing --reset --re_rank --amsgrad

CUDA_VISIBLE_DEVICES=0 python main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 50 --epochs 400 --decay_type step_320_380 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --save adam_1 --nGPU 1  --lr 2e-4 --optimizer ADAM --random_erasing --reset --re_rank --amsgrad

CUDA_VISIBLE_DEVICES=0 python main.py --datadir /home/hylink/eclipse-workspace/Market/ --batchid 16 --batchtest 32 --test_every 50 --epochs 400 --decay_type step_320_380 --loss 1*CrossEntropy+2*Triplet --margin 1.2 --save adam_1 --nGPU 1  --lr 2e-4 --optimizer ADAM --random_erasing --re_rank --load adam_1 --test_only --resume -1

修改trainer.py

import os
import torch
import numpy as np
import utils.utility as utility
from scipy.spatial.distance import cdist
from utils.functions import cmc, mean_ap
from utils.re_ranking import re_ranking
import MyUtil
import scipy.io
import matplotlib
import matplotlib.pyplot as plt

class Trainer
 
():
    def __init__(self, args, model, loss, loader, ckpt):
        self.args = args
        self.train_loader = loader.train_loader
        self.test_loader = loader.test_loader
        self.query_loader = loader.query_loader
        self.testset = loader.testset
        self.queryset = loader.queryset

        self.
 
ckpt = ckpt
        self.model = model
        self.loss = loss
        self.lr = 0.
        self.optimizer = utility.make_optimizer(args, self.model)
        self.scheduler = utility.make_scheduler(args, self.optimizer)
        self.device = torch.device('cpu' if args.cpu else 'cuda')

        if args.load != '':
            self.optimizer.load_state_dict(
                torch.load(os.path.join(ckpt.dir, 'optimizer.pt'))
            )
            for _ in range(len(ckpt.log)*args.test_every): self.scheduler.step()

    def train(self):
        self.scheduler.step()
        self.loss.step()
        epoch = self.scheduler.last_epoch + 1
        lr = self.scheduler.get_lr()[0]
        if lr != self.lr:
            self.ckpt.write_log('[INFO] Epoch: {}\tLearning rate: {:.2e}'.format(epoch, lr))
            self.lr = lr
        self.loss.start_log()
        self.model.train()

        for batch, (inputs, labels) in enumerate(self.train_loader):
            inputs = inputs.to(self.device)
            labels = labels.to(self.device)

            self.optimizer.zero_grad()
            outputs = self.model(inputs)
            loss = self.loss(outputs, labels)
            loss.backward()
            self.optimizer.step()

            self.ckpt.write_log('\r[INFO] [{}/{}]\t{}/{}\t{}'.format(
                epoch, self.args.epochs,
                batch + 1, len(self.train_loader),
                self.loss.display_loss(batch)), 
            end='' if batch+1 != len(self.train_loader) else '\n')

        self.loss.end_log(len(self.train_loader))

    def test(self):
        epoch = self.scheduler.last_epoch + 1
        self.ckpt.write_log('\n[INFO] Test:')
        self.model.eval()

        self.ckpt.add_log(torch.zeros(1, 5))
        qf = self.extract_feature(self.query_loader).numpy()
        gf = self.extract_feature(self.test_loader).numpy()

        if self.args.re_rank:
            q_g_dist = np.dot(qf, np.transpose(gf))
            q_q_dist = np.dot(qf, np.transpose(qf))
            g_g_dist = np.dot(gf, np.transpose(gf))
            dist = re_ranking(q_g_dist, q_q_dist, g_g_dist)
        else:
            dist = cdist(qf, gf)
        r = cmc(dist, self.queryset.ids, self.testset.ids, self.queryset.cameras, self.testset.cameras,
                separate_camera_set=False,
                single_gallery_shot=False,
                first_match_break=True)
        m_ap = mean_ap(dist, self.queryset.ids, self.testset.ids, self.queryset.cameras, self.testset.cameras)

        self.ckpt.log[-1, 0] = m_ap
        self.ckpt.log[-1, 1] = r[0]
        self.ckpt.log[-1, 2] = r[2]
        self.ckpt.log[-1, 3] = r[4]
        self.ckpt.log[-1, 4] = r[9]
        best = self.ckpt.log.max(0)
        self.ckpt.write_log(
            '[INFO] mAP: {:.4f} rank1: {:.4f} rank3: {:.4f} rank5: {:.4f} rank10: {:.4f} (Best: {:.4f} @epoch {})'.format(
            m_ap,
            r[0], r[2], r[4], r[9],
            best[0][0],
            (best[1][0] + 1)*self.args.test_every
            )
        )
        print(not self.args.test_only)
        if not self.args.test_only:
            self.ckpt.save(self, epoch, is_best=((best[1][0] + 1)*self.args.test_every == epoch))

    def fliphor(self, inputs):
        inv_idx = torch.arange(inputs.size(3)-1,-1,-1).long()  # N x C x H x W
        return inputs.index_select(3,inv_idx)

    def extract_feature(self, loader):
        features = torch.FloatTensor()
        for (inputs, labels) in loader:
            ff = torch.FloatTensor(inputs.size(0), 2048).zero_()
            for i in range(2):
                if i==1:
                    inputs = self.fliphor(inputs)
                input_img = inputs.to(self.device)
                outputs = self.model(input_img)
                f = outputs[0].data.cpu()
                ff = ff + f

            fnorm = torch.norm(ff, p=2, dim=1, keepdim=True)
            ff = ff.div(fnorm.expand_as(ff))

            features = torch.cat((features, ff), 0)
        return features

    def terminate(self):
        if self.args.test_only:
            self.test()
            return True
        else:
            epoch = self.scheduler.last_epoch + 1
            return epoch >= self.args.epochs


    def mytest(self):

        gallery_cam,gallery_label = MyUtil.get_id(self.testset.imgs)
        #print(gallery_label)
        query_cam,query_label = MyUtil.get_id(self.queryset.imgs)  
        #print(gallery_cam,gallery_label)
        self.ckpt.write_log('\n[INFO] MyTest:')
        self.model.eval()

        self.ckpt.add_log(torch.zeros(1, 5))
       
        gf = self.extract_feature(self.test_loader).numpy()
        qf = self.extract_feature(self.query_loader).numpy()
         
        result = {'gallery_f':gf,'gallery_label':gallery_label,'gallery_cam':gallery_cam,'query_f':qf,'query_label':query_label,'query_cam':query_cam}
        scipy.io.savemat('pytorch_result.mat',result)
        self.ckpt.write_log('\n[OVER]')



    def mydemo(self):
        result = scipy.io.loadmat('pytorch_result.mat')
        query_feature = torch.FloatTensor(result['query_f'])
        query_cam = result['query_cam'][0]
        query_label = result['query_label'][0]
        gallery_feature = torch.FloatTensor(result['gallery_f'])
        gallery_cam = result['gallery_cam'][0]
        gallery_label = result['gallery_label'][0]
        
        query_feature = query_feature.cuda()
        gallery_feature = gallery_feature.cuda()
       
        i = 2
        index = MyUtil.sort_img(query_feature[i],query_label[i],query_cam[i],gallery_feature,gallery_label,gallery_cam)
        
        # Visualize the rank result
        query_path = self.queryset.imgs[i]
        query_label = query_label[i]
        print(query_path)
        print('Top 10 images are as follow:')
        try: # Visualize Ranking Result 
            # Graphical User Interface is needed
            fig = plt.figure(figsize=(16,4))
            ax = plt.subplot(1,11,1)
            ax.axis('off')
            MyUtil.imshow(query_path,'query')
            for i in range(10):
                ax = plt.subplot(1,11,i+2)
                ax.axis('off')
                img_path = self.testset.imgs[index[i]]
                label = gallery_label[index[i]]
                MyUtil.imshow(img_path)
                if label == query_label:
                    ax.set_title('%d'%(i+1), color='green')
                else:
                    ax.set_title('%d'%(i+1), color='red')
                print(img_path)
        except RuntimeError:
            print('If you want to see the visualization of the ranking result, graphical user interface is needed.')
        
        fig.savefig("show.png")

修改main.py

import data
import loss
import torch
import model
from trainer import Trainer

from option import args
import utils.utility as utility
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

ckpt = utility.checkpoint(args)

loader = data.Data(args)
model = model.Model(args, ckpt)
loss = loss.Loss(args, ckpt) if not args.test_only else None
trainer = Trainer(args, model, loss, loader, ckpt)

'''
n = 0
while not trainer.terminate():
	n += 1
	trainer.train()
	if args.test_every!=0 and n%args.test_every==0:
		trainer.test()
'''
#trainer.mytest()
trainer.mydemo()

新建MyUtil.py

'''
Created on 2018年10月30日

@author: hylink
'''
import argparse
import scipy.io
import torch
import numpy as np
import os
from torchvision import datasets
import matplotlib
import matplotlib.pyplot as plt

def get_id(img_path):
    camera_id = []
    labels = []
    for path in img_path:
        #filename = path.split('/')[-1]
        filename = os.path.basename(path)
        label = filename[0:4]
        camera = filename.split('c')[1]
        if label[0:2]=='-1':
            labels.append(-1)
        else:
            labels.append(int(label))
        camera_id.append(int(camera[0]))
    return camera_id, labels

def imshow(path, title=None):
        """Imshow for Tensor."""
        im = plt.imread(path)
        plt.imshow(im)
        if title is not None:
            plt.title(title)
        plt.pause(0.001)  # pause a bit so that plots are updated 
        
 # sort the images
def sort_img(qf, ql, qc, gf, gl, gc):
    query = qf.view(-1,1)
    # print(query.shape)
    score = torch.mm(gf,query)
    score = score.squeeze(1).cpu()
    score = score.numpy()
    # predict index
    index = np.argsort(score)  #from small to large
    index = index[::-1]
    # index = index[0:2000]
    # good index
    query_index = np.argwhere(gl==ql)
    #same camera
    camera_index = np.argwhere(gc==qc)

    good_index = np.setdiff1d(query_index, camera_index, assume_unique=True)
    junk_index1 = np.argwhere(gl==-1)
    junk_index2 = np.intersect1d(query_index, camera_index)
    junk_index = np.append(junk_index2, junk_index1) 

    mask = np.in1d(index, junk_index, invert=True)
    index = index[mask

相關推薦

行人重識別(ReID) ——基於MGN-pytorch進行視覺化展示

模型訓練，修改demo.sh，將 --datadir修改已下載的Market1501資料集地址，將修改CUDA_VISIBLE_DEVICES=2,3自己的GPU裝置ID，將修改--nGPU自己的GPU數量。 部分demo.sh示例： #mAP: 0.920

行人重識別(ReID) ——基於Person_reID_baseline_pytorch修改業務流程

├── Market/ │ ├── bounding_box_test/ /* Files for testing (candidate images pool) │ ├── bounding_box_train/ /

行人重識別(ReID) ——技術實現及應用場景

導讀 跨鏡追蹤（Person Re-Identification，簡稱 ReID）技術是現在計算機視覺研究的熱門方向，主要解決跨攝像頭跨場景下行人的識別與檢索。該技術能夠根據行人的穿著、體態、髮型等資訊認知行人，與人臉識別結合能夠適用於更多新的應用場景，將人工智慧的認知水平提高到一個新階段。

CVPR2018行人重識別系列：用GAN進行資料增強

1.前言 近年CVPR2018錄用了很多person re-id相關論文，本著學習和總結的原則，來對目前行人重識別上最新的方法進行一個總結，由於本人水平有限，對於文章的理解可能存在不全面的地方，我儘可能的對方法進行的歸類，在每個類別下面對相關文章進行簡單介紹，也便於以後自己查閱。 本文主要

行人重識別(ReID) ——資料集描述 Market-1501

資料集簡介 　　Market-1501 資料集在清華大學校園中採集，夏天拍攝，在 2015 年構建並公開。它包括由6個攝像頭（其中5個高清攝像頭和1個低清攝像頭）拍攝到的 1501 個行人、32668 個檢測到的行人矩形框。每個行人至少由2個攝像頭捕獲到，並且在一個

行人重識別(ReID) ——資料集描述 CUHK03

資料集簡介 CUHK03是第一個足以進行深度學習的大規模行人重識別資料集，該資料集的影象採集於香港中文大學（CUHK）校園。資料以”cuhk-03.mat”的 MAT 檔案格式儲存，含有 1467 個不同的人物，由 5 對攝像頭採集。 目錄結構 CUHK-03

行人重識別(ReID)開原始碼

轉自：https://blog.csdn.net/Layumi1993/article/details/55798568?locationNum=2&fps=1關於行人重識別綜述，推薦一下liang zheng 2016年的綜述: Past, Present and

行人重識別(ReID) ——資料集描述 DukeMTMC-reID

資料集簡介 　　DukeMTMC 資料集是一個大規模標記的多目標多攝像機行人跟蹤資料集。它提供了一個由 8 個同步攝像機記錄的新型大型高清視訊資料集，具有 7,000 多個單攝像機軌跡和超過 2,700 多個獨立人物，DukeMTMC-reID 是 DukeMTMC

利用 ELK系統分析Nginx日誌並對資料進行視覺化展示

一、寫在前面 　　結合之前寫的一篇文章：Centos7 之安裝Logstash ELK stack 日誌管理系統，上篇文章主要講了監控軟體的作用以及部署方法。而這篇文章介紹的是單獨監控nginx 日誌分析再進行視覺化圖形展示，並在使用者前端使用nginx 來代理kibana

行人重識別簡介（Person ReID）

一、簡介 行人重識別，也被稱為 ReID(Person Re-identification)，是希望能夠利用計算機視覺的演算法來進行 跨攝像頭的追蹤，也就是找到不同攝像頭下的同一個人，這也是影象檢索的一個子問題 多個攝像頭下拍攝行人的角度不同，影象中的行

行人重識別AlignedReID 重點亮點學習資料整理

行人重識別（Person re-identification） 論文：AlignedReID: Surpassing Human-Level Performance in Person Re-Identification 曠視科技Face++的研究團隊–首次識別效果超越人

行人重識別 PCB-RPP，SGGNN

SIGAI特約作者 Fisher Yu CV在讀博士 研究方向：情感計算 什麼是行人重識別(ReID) 如下圖，給定一個行人圖或行人視訊作為查詢query，在大規模底庫中找出與其最相近的同一ID的行人圖或行人視訊。  

行人重識別簡介+資料集+核心論文點

  1、行人重識別是什麼？ 行人重識別（Person re-identification）也稱行人再識別，是利用計算機視覺技術判斷影象或者視訊序列中是否存在特定行人的技術。廣泛被認為是一個影象檢索的子問題。 給定一個監控行人影象，檢索跨裝置下的該行人影象。旨在彌補目前固定的攝像頭的

行人重識別資料集彙總

轉載自： https://blog.csdn.net/qiuchangyong/article/details/82219775 最近一段時間在做行人重識別方向的研究，行人重識別（Person Re-Identification）作為影象識別領域的一個分支，在實際生活中具有極其重要的意義。目

行人重識別——《A Systematic Evaluation and Benchmark for Person Re-Identification Features, Metrics, and D》

Benchmark演算法總結 論文：《A Systematic Evaluation and Benchmark for Person Re-Identification Features, Metrics, and Datasets》 論文提出了一套迄今為止最全面的

人臉重識別：行人重識別開源github

original url: http://blog.csdn.net/Layumi1993/article/details/55798568?locationNum=2&fps=1 關於行人重識別綜述，推薦一下liang zheng 2016年的綜述: Pas

行人重識別 (re-id)

行人重識別 這是近幾年挺火的一個的一個課題，大概就是研究不同攝像頭之間的人物匹配。如下圖： 這兩個攝像頭拍到的兩個人，現在我們的任務是檢測這兩個是否是同一個人。有些思路是在圖片上進行處理，但是這樣就忽略了人行為的特徵，我們這是基於

PRID：行人重識別學習視訊

視訊1： https://edu.csdn.net/course/play/8426?s=all 視訊2： https://www.bilibili.com/video/av13796843/oudao.com/ 視訊3： http://www.mooc.ai/

【行人重識別最新進展】2017-2018年行人重識別演算法精度統計

2017-2018年行人重識別演算法在開源資料集上的表現 Market-1501 Method Time Single Query Multi. Query rank-1 mAP

行人重識別學習之路：（一）基礎知識和相關資料整理

2018年4月16號，本人研一，今天正式確定了研究方向，從今天起，開始自己的行人重識別的學習之路，因為也是剛開始學習，所以這些筆記也都是在借鑑了經驗人士的文章後，再結合自己的理解和思路做出的整理，有不對的地方還請多多指教，本人會及時修改。1、行人重識別是什麼？ 行