def get_data(data_dir,
source,
target,
height,
width,
batch_size,
triplet_batch_size,
num_instances,
target_batch_size,
re=0,
workers=8):
dataset = DA(data_dir, source, target)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
num_classes = dataset.num_train_ids
train_transformer = T.Compose([
T.RandomSizedRectCrop(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
T.RandomErasing(EPSILON=re),
])
test_transformer = T.Compose([
T.Resize((height, width), interpolation=3),
T.ToTensor(),
normalizer,
])
source_train_loader = DataLoader(Preprocessor(
dataset.source_train,
root=osp.join(dataset.source_images_dir, dataset.source_train_path),
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=True,
pin_memory=True,
drop_last=True)
source_triplet_train_loader = DataLoader(
Preprocessor(dataset.source_train,
root=osp.join(dataset.source_images_dir,
dataset.source_train_path),
transform=train_transformer),
batch_size=triplet_batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(dataset.source_train, num_instances),
pin_memory=True,
drop_last=True)
target_train_loader = DataLoader(CameraPreprocessor(
dataset.target_train,
root=dataset.target_images_dir,
target_path=dataset.target_train_path,
target_camstyle_path=dataset.target_train_camstyle_path,
transform=train_transformer,
num_cam=dataset.target_num_cam),
batch_size=target_batch_size,
num_workers=workers,
shuffle=True,
pin_memory=True,
drop_last=True)
query_loader = DataLoader(Preprocessor(dataset.query,
root=osp.join(
dataset.target_images_dir,
dataset.query_path),
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
gallery_loader = DataLoader(Preprocessor(dataset.gallery,
root=osp.join(
dataset.target_images_dir,
dataset.gallery_path),
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
return dataset, num_classes, source_train_loader, source_triplet_train_loader, target_train_loader, query_loader, gallery_loader
def main(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.benchmark = True
# Create data loaders
assert args.num_instances > 1, "num_instances should be greater than 1"
assert args.batch_size % args.num_instances == 0, \
'num_instances should divide batch_size'
if args.height is None or args.width is None:
args.height, args.width = (144, 56) if args.arch == 'inception' else \
(256, 128)
# get source data
src_dataset, src_extfeat_loader = \
get_source_data(args.src_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# get target data
tgt_dataset, num_classes, tgt_extfeat_loader, test_loader = \
get_data(args.tgt_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# Create model
# Hacking here to let the classifier be the number of source ids
if args.src_dataset == 'dukemtmc':
model = models.create(args.arch, num_classes=632, pretrained=False)
elif args.src_dataset == 'market1501':
model = models.create(args.arch, num_classes=676, pretrained=False)
elif args.src_dataset == 'msmt17':
model = models.create(args.arch, num_classes=1041, pretrained=False)
elif args.src_dataset == 'cuhk03':
model = models.create(args.arch, num_classes=1230, pretrained=False)
else:
raise RuntimeError(
'Please specify the number of classes (ids) of the network.')
# Load from checkpoint
if args.resume:
print(
'Resuming checkpoints from finetuned model on another dataset...\n'
)
checkpoint = load_checkpoint(args.resume)
model.load_state_dict(checkpoint['state_dict'], strict=False)
else:
raise RuntimeWarning('Not using a pre-trained model.')
model = nn.DataParallel(model).cuda()
evaluator = Evaluator(model, print_freq=args.print_freq)
evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
# if args.evaluate: return
# Criterion
criterion = [
HoughTripletLoss(args.margin,
args.num_instances,
isAvg=False,
use_semi=False).cuda(),
HoughTripletLoss(args.margin,
args.num_instances,
isAvg=False,
use_semi=False).cuda()
]
# Optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
# training stage transformer on input images
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transformer = T.Compose([
T.Resize((args.height, args.width)),
T.RandomHorizontalFlip(),
T.ToTensor(), normalizer,
T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)
])
# # Start training
for iter_n in range(args.iteration):
if args.lambda_value == 0:
source_features = 0
else:
# get source datas' feature
source_features, _ = extract_features(model,
src_extfeat_loader,
print_freq=args.print_freq)
# synchronization feature order with src_dataset.train
source_features = torch.cat([
source_features[f].unsqueeze(0)
for f, _, _, _ in src_dataset.train
], 0)
# extract training images' features
print('Iteration {}: Extracting Target Dataset Features...'.format(
iter_n + 1))
target_features, _ = extract_features(model,
tgt_extfeat_loader,
print_freq=args.print_freq)
# synchronization feature order with dataset.train
target_features = torch.cat([
target_features[f].unsqueeze(0)
for f, _, _, _ in tgt_dataset.trainval
], 0)
# calculate distance and rerank result
print('Calculating feature distances...')
target_features = target_features.numpy()
rerank_dist = re_ranking(source_features,
target_features,
lambda_value=args.lambda_value)
if iter_n == 0:
# DBSCAN cluster
tri_mat = np.triu(rerank_dist, 1) # tri_mat.dim=2
tri_mat = tri_mat[np.nonzero(tri_mat)] # tri_mat.dim=1
tri_mat = np.sort(tri_mat, axis=None)
top_num = np.round(args.rho * tri_mat.size).astype(int)
eps = tri_mat[:top_num].mean()
print('eps in cluster: {:.3f}'.format(eps))
cluster = DBSCAN(eps=eps,
min_samples=4,
metric='precomputed',
n_jobs=8)
# select & cluster images as training set of this epochs
print('Clustering and labeling...')
labels = cluster.fit_predict(rerank_dist)
num_ids = len(set(labels)) - 1
print('Iteration {} have {} training ids'.format(iter_n + 1, num_ids))
# generate new dataset
new_dataset, unknown_dataset = [], []
# assign label for target ones
unknownLab = labelNoise(torch.from_numpy(target_features),
torch.from_numpy(labels))
# unknownFeats = target_features[labels==-1,:]
unCounter, index = 0, 0
from collections import defaultdict
realIDs, fakeIDs = defaultdict(list), []
record_labels = {}
hough = Hough(8, 40, 230, 2935, 25, args.short_cut)
for (fname, realPID, cam,
timestamp), label in zip(tgt_dataset.trainval, labels):
if label == -1:
unknown_dataset.append((fname, int(unknownLab[unCounter]), cam,
timestamp)) # unknown data
fakeIDs.append(int(unknownLab[unCounter]))
realIDs[realPID].append(index)
unCounter += 1
index += 1
continue
# dont need to change codes in trainer.py _parsing_input function and sampler function after add 0
if label not in record_labels:
record_labels[label] = []
for index2 in record_labels[label]:
hough.update(cam, tgt_dataset.trainval[index2][2], timestamp,
tgt_dataset.trainval[index2][3])
record_labels[label].append(index)
new_dataset.append((fname, label, cam, timestamp))
fakeIDs.append(label)
realIDs[realPID].append(index)
index += 1
print('Iteration {} have {} training images'.format(
iter_n + 1, len(new_dataset)))
precision, recall, fscore = calScores(
realIDs, np.asarray(fakeIDs)) # fakeIDs does not contain -1
print('precision:{}, recall:{}, fscore: {}'.format(
100 * precision, 100 * recall, fscore))
T_pseu, TP_pseu, T_gt, TP_gt, index = (0, 0, 0, 0, -1)
for (fname, realPID, cam,
timestamp), label in zip(tgt_dataset.trainval, labels):
index += 1
# calc by gt label
T_gt = T_gt + len(realIDs[realPID]) - 1
for index2 in realIDs[realPID]:
if index2 == index: continue
if hough.on_peak(cam, tgt_dataset.trainval[index2][2],
timestamp, tgt_dataset.trainval[index2][3]):
TP_gt += 1
# calc by pseudo label
if label == -1: continue
T_pseu = T_pseu + len(record_labels[label]) - 1
for index2 in record_labels[label]:
if index2 == index: continue
if hough.on_peak(cam, tgt_dataset.trainval[index2][2],
timestamp, tgt_dataset.trainval[index2][3]):
TP_pseu += 1
print('gt label: T = %d, TP = %d, recall = %f' %
(T_gt, TP_gt, TP_pseu / T_gt))
print('pseudo label: T = %d, TP = %d, recall = %f' %
(T_pseu, TP_pseu, TP_pseu / T_pseu))
train_loader = DataLoader(Preprocessor(new_dataset,
root=tgt_dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size,
num_workers=4,
sampler=RandomIdentitySampler(
new_dataset, args.num_instances),
pin_memory=True,
drop_last=True)
# hard samples
# noiseImgs = [name[1] for name in unknown_dataset]
# saveAll(noiseImgs, tgt_dataset.images_dir, 'noiseImg')
# import ipdb; ipdb.set_trace()
unLoader = DataLoader(Preprocessor(unknown_dataset,
root=tgt_dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size,
num_workers=4,
sampler=RandomIdentitySampler(
unknown_dataset, args.num_instances),
pin_memory=True,
drop_last=True)
# train model with new generated dataset
trainer1 = HoughTrainer(model, hough, train_loader, criterion,
optimizer)
trainer2 = HoughTrainer(model, hough, unLoader, criterion, optimizer)
# Start training
for epoch in range(args.epochs):
trainer1.train(epoch)
trainer2.train(epoch)
# test only
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
# print('co-model:\n')
# rank_score = evaluatorB.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
# Evaluate
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'epoch': epoch + 1,
'best_top1': rank_score.market1501[0],
},
True,
fpath=osp.join(args.logs_dir, 'asyCo.pth'))
return rank_score.map, rank_score.market1501[0]
def get_data(name,
split_id,
data_dir,
height,
width,
batch_size,
num_instances,
workers,
combine_trainval,
eval_rerank=False):
## Datasets
if name == 'cuhk03labeled':
dataset_name = 'cuhk03'
dataset = data_manager.init_imgreid_dataset(
root=data_dir,
name=dataset_name,
split_id=split_id,
cuhk03_labeled=True,
cuhk03_classic_split=False,
)
dataset.images_dir = osp.join(data_dir, '/CUHK03_New/images_labeled/')
elif name == 'cuhk03detected':
dataset_name = 'cuhk03'
dataset = data_manager.init_imgreid_dataset(
root=data_dir,
name=dataset_name,
split_id=split_id,
cuhk03_labeled=False,
cuhk03_classic_split=False,
)
dataset.images_dir = osp.join(data_dir, '/CUHK03_New/images_detected/')
## Num. of training IDs
num_classes = dataset.num_train_pids
train_transformer = T.Compose([
T.Random2DTranslation(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(),
])
test_transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
])
train_loader = DataLoader(Preprocessor(dataset.train,
root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
dataset.train, num_instances),
pin_memory=True,
drop_last=True)
query_loader = DataLoader(Preprocessor(dataset.query,
root=dataset.images_dir,
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
gallery_loader = DataLoader(Preprocessor(dataset.gallery,
root=dataset.images_dir,
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
return dataset, num_classes, train_loader, query_loader, gallery_loader
def get_data(name, split_id, data_dir, height, width, batch_size,
num_instances, workers, combine_trainval, flip_prob, padding,
re_prob):
root = osp.join(data_dir, name)
print(root)
dataset = datasets.create(name, root, split_id=split_id)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
trainvallabel = dataset.trainvallabel
train_set = dataset.trainval if combine_trainval else dataset.train
num_classes = (dataset.num_trainval_ids
if combine_trainval else dataset.num_train_ids)
train_transformer = T.Compose([
T.Resize((height, width)),
T.RandomHorizontalFlip(),
T.Pad(padding),
T.RandomCrop((height, width)),
T.ToTensor(), normalizer,
RandomErasing(probability=re_prob, mean=[0.485, 0.456, 0.406])
])
# train_transformer = T.Compose([
# T.RandomSizedRectCrop(height, width),
# T.RandomHorizontalFlip(),
# T.ToTensor(),
# normalizer,
# ])
test_transformer = T.Compose([
T.Resize((height, width)),
T.ToTensor(),
normalizer,
])
val_loader = DataLoader(Preprocessor(dataset.val,
root=dataset.images_dir,
transform=test_transformer),
batch_size=32,
num_workers=workers,
shuffle=False,
pin_memory=True)
query_loader = DataLoader(Preprocessor(list(set(dataset.query)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=32,
num_workers=workers,
sampler=CamSampler(list(set(dataset.query)),
[2, 5]),
shuffle=False,
pin_memory=True)
gallery_loader = DataLoader(Preprocessor(list(set(dataset.gallery)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=32,
num_workers=workers,
sampler=CamSampler(list(set(dataset.gallery)),
[0, 1, 3, 4], 4),
shuffle=False,
pin_memory=True)
train_loader = DataLoader(Preprocessor(train_set,
root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
train_set, num_instances),
pin_memory=True,
drop_last=True)
query_loader_rgb = DataLoader(Preprocessor(list(set(dataset.query)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=32,
num_workers=workers,
sampler=CamSampler(list(set(dataset.query)),
[0, 1, 3, 4]),
shuffle=False,
pin_memory=True)
gallery_loader_rgb = DataLoader(Preprocessor(list(set(dataset.gallery)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=32,
num_workers=workers,
sampler=CamSampler(
list(set(dataset.gallery)),
[0, 1, 3, 4], 4),
shuffle=False,
pin_memory=True)
query_loader_ir = DataLoader(Preprocessor(list(set(dataset.query)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=32,
num_workers=workers,
sampler=CamSampler(list(set(dataset.query)),
[2, 5]),
shuffle=False,
pin_memory=True)
gallery_loader_ir = DataLoader(Preprocessor(list(set(dataset.gallery)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=32,
num_workers=workers,
sampler=CamSampler(
list(set(dataset.gallery)), [2, 5], 2),
shuffle=False,
pin_memory=True)
return dataset, num_classes, train_loader, trainvallabel, val_loader, query_loader, gallery_loader, query_loader_rgb, gallery_loader_rgb, query_loader_ir, gallery_loader_ir
def get_data(name, data_dir, height, width, ratio, batch_size, workers,
num_instances):
root = osp.join(data_dir, name)
root = data_dir
dataset = datasets.create(name, root)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
num_classes = dataset.num_train_ids
train_transformer = T.Compose([
# T.RandomSizedRectCrop(height, width),
# T.RectScale(height, width),
T.ContVerticalCrop(height, width, ratio),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
])
test_transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
normalizer,
])
query_transformer = T.Compose([
T.ContVerticalCropDiscret(height, width, ratio),
T.ToTensor(),
normalizer,
])
train_loader = DataLoader(
Preprocessor(dataset.train,
root=osp.join(dataset.images_dir, dataset.train_path),
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(dataset.train, num_instances),
pin_memory=True,
drop_last=True)
query_loader = DataLoader(Preprocessor(dataset.query,
root=osp.join(
dataset.images_dir,
dataset.query_path),
transform=query_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
gallery_loader = DataLoader(Preprocessor(dataset.gallery,
root=osp.join(
dataset.images_dir,
dataset.gallery_path),
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
return dataset, num_classes, train_loader, query_loader, gallery_loader
def get_data(data_dir, height, width, batch_size, num_instances, re=0, workers=8):
dataset = DA(data_dir)
test_dataset = TotalData(data_dir)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
num_classes = dataset.num_source_ids
train_transformer = T.Compose([
T.Resize((256, 128), interpolation=3),
T.Pad(10),
T.RandomCrop((256,128)),
T.RandomHorizontalFlip(0.5),
T.RandomRotation(5),
T.ColorJitter(brightness=(0.5, 2.0), saturation=(0.5, 2.0), hue=(-0.1, 0.1)),
T.ToTensor(),
normalizer,
# T.RandomErasing(EPSILON=re),
])
test_transformer = T.Compose([
T.Resize((256, 128), interpolation=3),
T.ToTensor(),
normalizer,
])
# Train
source_train_loader = DataLoader(
Preprocessor(dataset.source_train,
transform=train_transformer),
batch_size=batch_size, num_workers=workers,
# shuffle=True, pin_memory=True, drop_last=True)
sampler=RandomIdentitySampler(dataset.source_train, batch_size, num_instances),
pin_memory=True, drop_last=True)
# Test
grid_query_loader = DataLoader(
Preprocessor(test_dataset.grid_query,
root=osp.join(test_dataset.grid_images_dir, test_dataset.query_path), transform=test_transformer),
batch_size=64, num_workers=4,
shuffle=False, pin_memory=True)
grid_gallery_loader = DataLoader(
Preprocessor(test_dataset.grid_gallery,
root=osp.join(test_dataset.grid_images_dir, test_dataset.gallery_path), transform=test_transformer),
batch_size=64, num_workers=4,
shuffle=False, pin_memory=True)
prid_query_loader = DataLoader(
Preprocessor(test_dataset.prid_query,
root=osp.join(test_dataset.prid_images_dir, test_dataset.query_path), transform=test_transformer),
batch_size=64, num_workers=4,
shuffle=False, pin_memory=True)
prid_gallery_loader = DataLoader(
Preprocessor(test_dataset.prid_gallery,
root=osp.join(test_dataset.prid_images_dir, test_dataset.gallery_path), transform=test_transformer),
batch_size=64, num_workers=4,
shuffle=False, pin_memory=True)
viper_query_loader = DataLoader(
Preprocessor(test_dataset.viper_query,
root=osp.join(test_dataset.viper_images_dir, test_dataset.query_path), transform=test_transformer),
batch_size=64, num_workers=4,
shuffle=False, pin_memory=True)
viper_gallery_loader = DataLoader(
Preprocessor(test_dataset.viper_gallery,
root=osp.join(test_dataset.viper_images_dir, test_dataset.gallery_path), transform=test_transformer),
batch_size=64, num_workers=4,
shuffle=False, pin_memory=True)
ilid_query_loader = DataLoader(
Preprocessor(test_dataset.ilid_query,
root=osp.join(test_dataset.ilid_images_dir, "images"), transform=test_transformer),
batch_size=64, num_workers=4,
shuffle=False, pin_memory=True)
ilid_gallery_loader = DataLoader(
Preprocessor(test_dataset.ilid_gallery,
root=osp.join(test_dataset.ilid_images_dir, "images"), transform=test_transformer),
batch_size=64, num_workers=4,
shuffle=False, pin_memory=True)
return dataset, test_dataset, num_classes, source_train_loader, grid_query_loader, grid_gallery_loader,prid_query_loader, prid_gallery_loader,viper_query_loader, viper_gallery_loader, ilid_query_loader, ilid_gallery_loader
def main(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.benchmark = True
# Create data loaders
assert args.num_instances > 1, "num_instances should be greater than 1"
assert args.batch_size % args.num_instances == 0, \
'num_instances should divide batch_size'
if args.height is None or args.width is None:
args.height, args.width = (144, 56) if args.arch == 'inception' else \
(256, 128)
# get source data
src_dataset, src_extfeat_loader = \
get_source_data(args.src_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# get target data
tgt_dataset, num_classes, tgt_extfeat_loader, test_loader = \
get_data(args.tgt_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# Create model
# Hacking here to let the classifier be the number of source ids
if args.src_dataset == 'dukemtmc':
model = models.create(args.arch, num_classes=632, pretrained=False)
coModel = models.create(args.arch, num_classes=632, pretrained=False)
elif args.src_dataset == 'market1501':
model = models.create(args.arch, num_classes=676, pretrained=False)
coModel = models.create(args.arch, num_classes=676, pretrained=False)
elif args.src_dataset == 'msmt17':
model = models.create(args.arch, num_classes=1041, pretrained=False)
coModel = models.create(args.arch, num_classes=1041, pretrained=False)
elif args.src_dataset == 'cuhk03':
model = models.create(args.arch, num_classes=1230, pretrained=False)
coModel = models.create(args.arch, num_classes=1230, pretrained=False)
else:
raise RuntimeError(
'Please specify the number of classes (ids) of the network.')
# Load from checkpoint
if args.resume:
print(
'Resuming checkpoints from finetuned model on another dataset...\n'
)
checkpoint = load_checkpoint(args.resume)
model.load_state_dict(checkpoint['state_dict'], strict=False)
coModel.load_state_dict(checkpoint['state_dict'], strict=False)
else:
raise RuntimeWarning('Not using a pre-trained model.')
model = nn.DataParallel(model).cuda()
coModel = nn.DataParallel(coModel).cuda()
# Criterion
criterion = [
TripletLoss(args.margin,
args.num_instances,
isAvg=False,
use_semi=False).cuda(),
TripletLoss(args.margin,
args.num_instances,
isAvg=False,
use_semi=False).cuda()
]
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
coOptimizer = torch.optim.Adam(coModel.parameters(), lr=args.lr)
optims = [optimizer, coOptimizer]
# training stage transformer on input images
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transformer = T.Compose([
T.Resize((args.height, args.width)),
T.RandomHorizontalFlip(),
T.ToTensor(), normalizer,
T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)
])
# # Start training
for iter_n in range(args.iteration):
if args.lambda_value == 0:
source_features = 0
else:
# get source datas' feature
source_features, _ = extract_features(model,
src_extfeat_loader,
print_freq=args.print_freq,
numStripe=None)
# synchronization feature order with src_dataset.train
source_features = torch.cat([
source_features[f].unsqueeze(0)
for f, _, _ in src_dataset.train
], 0)
# extract training images' features
print('Iteration {}: Extracting Target Dataset Features...'.format(
iter_n + 1))
target_features, _ = extract_features(model,
tgt_extfeat_loader,
print_freq=args.print_freq,
numStripe=None)
# synchronization feature order with dataset.train
target_features = torch.cat([
target_features[f].unsqueeze(0) for f, _, _ in tgt_dataset.trainval
], 0)
# calculate distance and rerank result
print('Calculating feature distances...')
target_features = target_features.numpy()
rerank_dist = re_ranking(source_features,
target_features,
lambda_value=args.lambda_value)
if iter_n == 0:
# DBSCAN cluster
tri_mat = np.triu(rerank_dist, 1) # tri_mat.dim=2
tri_mat = tri_mat[np.nonzero(tri_mat)] # tri_mat.dim=1
tri_mat = np.sort(tri_mat, axis=None)
top_num = np.round(args.rho * tri_mat.size).astype(int)
eps = tri_mat[:top_num].mean()
print('eps in cluster: {:.3f}'.format(eps))
cluster = DBSCAN(eps=eps,
min_samples=4,
metric='precomputed',
n_jobs=8)
# select & cluster images as training set of this epochs
print('Clustering and labeling...')
labels = cluster.fit_predict(rerank_dist)
num_ids = len(set(labels)) - 1
print('Iteration {} have {} training ids'.format(iter_n + 1, num_ids))
# generate new dataset
new_dataset = []
# assign label for target ones
newLab = labelNoise(torch.from_numpy(target_features),
torch.from_numpy(labels))
# unknownFeats = target_features[labels==-1,:]
counter = 0
from collections import defaultdict
realIDs, fakeIDs = defaultdict(list), []
for (fname, realID, cam), label in zip(tgt_dataset.trainval, newLab):
# dont need to change codes in trainer.py _parsing_input function and sampler function after add 0
new_dataset.append((fname, label, cam))
realIDs[realID].append(counter)
fakeIDs.append(label)
counter += 1
precision, recall, fscore = calScores(realIDs, np.asarray(fakeIDs))
print('Iteration {} have {} training images'.format(
iter_n + 1, len(new_dataset)))
print(
f'precision:{precision * 100}, recall:{100 * recall}, fscore:{100 * fscore}'
)
train_loader = DataLoader(Preprocessor(new_dataset,
root=tgt_dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size,
num_workers=4,
sampler=RandomIdentitySampler(
new_dataset, args.num_instances),
pin_memory=True,
drop_last=True)
trainer = CoTeaching(model, coModel, train_loader, criterion, optims)
# Start training
for epoch in range(args.epochs):
trainer.train(epoch,
remRate=0.2 + (0.8 / args.iteration) *
(1 + iter_n)) # to at most 80%
# test only
evaluator = Evaluator(model, print_freq=args.print_freq)
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
# Evaluate
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'epoch': epoch + 1,
'best_top1': rank_score.market1501[0],
},
True,
fpath=osp.join(args.logs_dir, 'adapted.pth.tar'))
return rank_score.map, rank_score.market1501[0]
def main(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.benchmark = True
# Create data loaders
assert args.num_instances > 1, "num_instances should be greater than 1"
assert args.batch_size % args.num_instances == 0, \
'num_instances should divide batch_size'
if args.height is None or args.width is None:
args.height, args.width = (144, 56) if args.arch == 'inception' else \
(256, 128)
# get source data
src_dataset, src_extfeat_loader = \
get_source_data(args.src_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# get target data
tgt_dataset, num_classes, tgt_extfeat_loader, test_loader = \
get_data(args.tgt_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# Create model
# Hacking here to let the classifier be the number of source ids
if args.src_dataset == 'dukemtmc':
model = models.create(args.arch, num_classes=632, pretrained=False)
elif args.src_dataset == 'market1501':
model = models.create(args.arch, num_classes=676, pretrained=False)
else:
raise RuntimeError(
'Please specify the number of classes (ids) of the network.')
# Load from checkpoint
if args.resume:
print(
'Resuming checkpoints from finetuned model on another dataset...\n'
)
checkpoint = load_checkpoint(args.resume)
model.load_state_dict(checkpoint['state_dict'], strict=False)
else:
raise RuntimeWarning('Not using a pre-trained model.')
model = nn.DataParallel(model).cuda()
# evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
# if args.evaluate: return
# Criterion
criterion = [
TripletLoss(args.margin, args.num_instances, isAvg=True,
use_semi=True).cuda(),
TripletLoss(args.margin, args.num_instances, isAvg=True,
use_semi=True).cuda(), None, None
]
# Optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
# training stage transformer on input images
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transformer = T.Compose([
T.Resize((args.height, args.width)),
T.RandomHorizontalFlip(),
T.ToTensor(), normalizer,
T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)
])
evaluator = Evaluator(model, print_freq=args.print_freq)
evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
# # Start training
for iter_n in range(args.iteration):
if args.lambda_value == 0:
source_features = 0
else:
# get source datas' feature
source_features, _ = extract_features(model,
src_extfeat_loader,
print_freq=args.print_freq)
# synchronization feature order with src_dataset.train
source_features = torch.cat([
source_features[f].unsqueeze(0)
for f, _, _, _ in src_dataset.train
], 0)
# extract training images' features
print('Iteration {}: Extracting Target Dataset Features...'.format(
iter_n + 1))
target_features, tarNames = extract_features(
model, tgt_extfeat_loader, print_freq=args.print_freq)
# synchronization feature order with dataset.train
target_features = torch.cat([
target_features[f].unsqueeze(0)
for f, _, _, _ in tgt_dataset.trainval
], 0)
# target_real_label = np.asarray([tarNames[f].unsqueeze(0) for f, _, _, _ in tgt_dataset.trainval])
# calculate distance and rerank result
# method 1
target_features = target_features.numpy()
rerank_dist = re_ranking(source_features,
target_features,
lambda_value=args.lambda_value)
# method 2
# distmat_qq = calDis(source_features, source_features)
# distmat_qg = calDis(source_features, target_features)
# distmat_gg = calDis(target_features, target_features)
# rerank_dist = re_ranking2(distmat_qg.numpy(), distmat_qq.numpy(), distmat_gg.numpy())
cluster = HDBSCAN(metric='precomputed', min_samples=10)
# select & cluster images as training set of this epochs
clusterRes = cluster.fit(rerank_dist)
labels, label_num = clusterRes.labels_, clusterRes.labels_.max() + 1
centers = np.zeros((label_num, target_features.shape[1]))
nums = [0] * target_features.shape[1]
print('clusters num =', label_num)
# generate new dataset
new_dataset = []
index = -1
for (fname, _, cam, timestamp), label in zip(tgt_dataset.trainval,
labels):
index += 1
if label == -1: continue
# dont need to change codes in trainer.py _parsing_input function and sampler function after add 0
new_dataset.append((fname, label, cam, timestamp))
centers[label] += target_features[index]
nums[label] += 1
print('Iteration {} have {} training images'.format(
iter_n + 1, len(new_dataset)))
train_loader = DataLoader(Preprocessor(new_dataset,
root=tgt_dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size,
num_workers=4,
sampler=RandomIdentitySampler(
new_dataset, args.num_instances),
pin_memory=True,
drop_last=True)
for i in range(label_num):
centers[i] /= nums[i]
criterion[3] = ClassificationLoss(normalize(centers, axis=1)).cuda()
classOptimizer = torch.optim.Adam(
[{
'params': model.parameters()
}, {
'params': criterion[3].classifier.parameters(),
'lr': 1e-3
}],
lr=args.lr)
class_trainer = ClassificationTrainer(model, train_loader, criterion,
classOptimizer)
for epoch in range(args.epochs):
class_trainer.train(epoch)
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
# Evaluate
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'epoch': epoch + 1,
'best_top1': rank_score.market1501[0],
},
True,
fpath=osp.join(args.logs_dir, 'adapted.pth.tar'))
return (rank_score.map, rank_score.market1501[0])
def main(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.benchmark = True
# Create data loaders
assert args.num_instances > 1, "num_instances should be greater than 1"
assert args.batch_size % args.num_instances == 0, \
'num_instances should divide batch_size'
if args.height is None or args.width is None:
args.height, args.width = (144, 56) if args.arch == 'inception' else \
(256, 128)
# get source data
src_dataset, src_extfeat_loader = \
get_source_data(args.src_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# get target data
tgt_dataset, num_classes, tgt_extfeat_loader, test_loader = \
get_data(args.tgt_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# Create model
# Hacking here to let the classifier be the number of source ids
if args.src_dataset == 'dukemtmc':
model = models.create(args.arch, num_classes=632, pretrained=False)
elif args.src_dataset == 'market1501':
model = models.create(args.arch, num_classes=676, pretrained=False)
else:
raise RuntimeError(
'Please specify the number of classes (ids) of the network.')
# Load from checkpoint
if args.resume:
print(
'Resuming checkpoints from finetuned model on another dataset...\n'
)
checkpoint = load_checkpoint(args.resume)
model.load_state_dict(checkpoint['state_dict'], strict=False)
else:
raise RuntimeWarning('Not using a pre-trained model.')
model = nn.DataParallel(model).cuda()
# Distance metric
# metric = DistanceMetric(algorithm=args.dist_metric)
# Evaluator
evaluator = Evaluator(model, print_freq=args.print_freq)
print(
"Test with the original model trained on source domain (direct transfer):"
)
rank_score_best = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
best_map = rank_score_best.map #market1501[0]-->rank-1
if args.evaluate:
return
# Criterion
criterion = [
TripletLoss(args.margin, args.num_instances).cuda(),
TripletLoss(args.margin, args.num_instances).cuda(),
AccumulatedLoss(args.margin, args.num_instances).cuda(),
]
# Optimizer
optimizer = torch.optim.SGD(
model.parameters(),
lr=args.lr,
momentum=0.9,
)
# training stage transformer on input images
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transformer = T.Compose([
T.Resize((args.height, args.width)),
T.RandomHorizontalFlip(),
T.ToTensor(), normalizer,
T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)
])
# Start training
for iter_n in range(args.iteration):
if args.lambda_value == 0:
source_features = 0 #this value controls the usage of source data
else:
# get source datas' feature
source_features, _ = extract_features(model,
src_extfeat_loader,
print_freq=args.print_freq)
# synchronization feature order with src_dataset.train
source_features = torch.cat([
source_features[f].unsqueeze(0)
for f, _, _ in src_dataset.train
], 0)
# extract training images' features
print('Iteration {}: Extracting Target Dataset Features...'.format(
iter_n + 1))
target_features, _ = extract_features(model,
tgt_extfeat_loader,
print_freq=args.print_freq)
# synchronization feature order with dataset.train
target_features = torch.cat([
target_features[f].unsqueeze(0) for f, _, _ in tgt_dataset.trainval
], 0)
# calculate distance and rerank result
print('Calculating feature distances...')
target_features = target_features.numpy()
rerank_dist = re_ranking(source_features,
target_features,
lambda_value=args.lambda_value)
if iter_n == 0:
# DBSCAN cluster
tri_mat = np.triu(rerank_dist, 1) # tri_mat.dim=2
tri_mat = tri_mat[np.nonzero(tri_mat)] # tri_mat.dim=1
tri_mat = np.sort(tri_mat, axis=None)
top_num = np.round(args.rho * tri_mat.size).astype(int)
eps = tri_mat[:top_num].mean()
print('eps in cluster: {:.3f}'.format(eps))
cluster = DBSCAN(eps=eps,
min_samples=4,
metric='precomputed',
n_jobs=8)
# HDBSCAN cluster
import hdbscan
cluster_hdbscan = hdbscan.HDBSCAN(min_cluster_size=10,
min_samples=4,
metric='precomputed')
# select & cluster images as training set of this epochs
print('Clustering and labeling...')
if args.use_hdbscan_clustering:
print(
'Use the better chlustering algorithm HDBSCAN for clustering')
labels = cluster_hdbscan.fit_predict(rerank_dist)
else:
print('Use DBSCAN for clustering')
labels = cluster.fit_predict(rerank_dist)
num_ids = len(set(labels)) - 1
print('Iteration {} have {} training ids'.format(iter_n + 1, num_ids))
# generate new dataset
new_dataset = []
for (fname, _, _), label in zip(tgt_dataset.trainval, labels):
if label == -1:
continue
# dont need to change codes in trainer.py _parsing_input function and sampler function after add 0
new_dataset.append((fname, label, 0))
print('Iteration {} have {} training images'.format(
iter_n + 1, len(new_dataset)))
train_loader = DataLoader(Preprocessor(new_dataset,
root=tgt_dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size,
num_workers=4,
sampler=RandomIdentitySampler(
new_dataset, args.num_instances),
pin_memory=True,
drop_last=True)
# train model with new generated dataset
trainer = Trainer(model, criterion, print_freq=args.print_freq)
evaluator = Evaluator(model, print_freq=args.print_freq)
# Start training
for epoch in range(args.epochs):
trainer.train(epoch, train_loader, optimizer)
# Evaluate
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
#Save the best ckpt:
rank1 = rank_score.market1501[0]
mAP = rank_score.map
is_best_mAP = mAP > best_map
best_map = max(mAP, best_map)
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'epoch': iter_n + 1,
'best_mAP': best_map,
# 'num_ids': num_ids,
},
is_best_mAP,
fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar'))
print(
'\n * Finished epoch {:3d} top1: {:5.1%} mAP: {:5.1%} best_mAP: {:5.1%}{}\n'
.format(iter_n + 1, rank1, mAP, best_map,
' *' if is_best_mAP else ''))
return (rank_score.map, rank_score.market1501[0])
def get_data(data_dir, source, target, height, width, batch_size, re=0, workers=8):
dataset = DA(data_dir, source, target)
dataset_2 = DA(data_dir, target, source)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
num_classes = dataset.num_train_ids
train_transformer = T.Compose([
T.Resize((height, width), interpolation=3),
T.RandomHorizontalFlip(p=0.5),
T.Pad(10),
T.RandomCrop((height, width)),
T.ToTensor(),
normalizer,
# T.RandomErasing(EPSILON=re),
T.RandomErasing(probability=0.4, mean=[0.485, 0.456, 0.406])
])
train_transformer_2 = T.Compose([
T.Resize((height, width), interpolation=3),
T.RandomHorizontalFlip(p=0.5),
T.Pad(10),
T.RandomCrop((height, width)),
T.ToTensor(),
normalizer,
# T.RandomErasing(EPSILON=re),
T.RandomErasing(probability=0.4, mean=[0.485, 0.456, 0.406])
])
test_transformer = T.Compose([
T.Resize((height, width), interpolation=3),
T.ToTensor(),
normalizer,
])
'''
num_instances=4
rmgs_flag = num_instances > 0
if rmgs_flag:
sampler = RandomIdentitySampler(dataset.target_train, num_instances)
else:
sampler = None
'''
source_train_loader = DataLoader(
Preprocessor(dataset.source_train, root=osp.join(dataset.source_images_dir, dataset.source_train_path),
transform=train_transformer),
batch_size=batch_size, num_workers=workers,
shuffle=True, pin_memory=True, drop_last=True)
num_instances=0
rmgs_flag = num_instances > 0
if rmgs_flag:
sampler = RandomIdentitySampler(dataset.target_train, num_instances)
else:
sampler = None
target_train_loader = DataLoader(
UnsupervisedCamStylePreprocessor(dataset.target_train,
root=osp.join(dataset.target_images_dir, dataset.target_train_path),
camstyle_root=osp.join(dataset.target_images_dir,
dataset.target_train_camstyle_path),
num_cam=dataset.target_num_cam, transform=train_transformer),
batch_size=batch_size, num_workers=workers,
shuffle=True, pin_memory=True, drop_last=True)
query_loader = DataLoader(
Preprocessor(dataset.query,
root=osp.join(dataset.target_images_dir, dataset.query_path), transform=test_transformer),
batch_size=batch_size, num_workers=workers,
shuffle=False, pin_memory=True)
query_loader_2 = DataLoader(
Preprocessor(dataset_2.query,
root=osp.join(dataset_2.target_images_dir, dataset_2.query_path), transform=test_transformer),
batch_size=batch_size, num_workers=workers,
shuffle=False, pin_memory=True)
gallery_loader = DataLoader(
Preprocessor(dataset.gallery,
root=osp.join(dataset.target_images_dir, dataset.gallery_path), transform=test_transformer),
batch_size=batch_size, num_workers=workers,
shuffle=False, pin_memory=True)
gallery_loader_2 = DataLoader(
Preprocessor(dataset_2.gallery,
root=osp.join(dataset_2.target_images_dir, dataset_2.gallery_path), transform=test_transformer),
batch_size=batch_size, num_workers=workers,
shuffle=False, pin_memory=True)
return dataset,dataset_2, num_classes, source_train_loader, target_train_loader, query_loader, gallery_loader, query_loader_2, gallery_loader_2
def main(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.benchmark = True
# Create data loaders
assert args.num_instances > 1, "num_instances should be greater than 1"
assert args.batch_size % args.num_instances == 0, \
'num_instances should divide batch_size'
if args.height is None or args.width is None:
args.height, args.width = (144, 56) if args.arch == 'inception' else \
(256, 128)
# get source data
src_dataset, src_extfeat_loader = \
get_source_data(args.src_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# get target data
tgt_dataset, num_classes, tgt_extfeat_loader, test_loader = \
get_data(args.tgt_dataset, args.data_dir, args.height,
args.width, args.batch_size, args.workers)
# Create model
# Hacking here to let the classifier be the number of source ids
if args.src_dataset == 'dukemtmc':
model = models.create(args.arch, num_classes=632, pretrained=False)
elif args.src_dataset == 'market1501':
model = models.create(args.arch, num_classes=676, pretrained=False)
else:
raise RuntimeError(
'Please specify the number of classes (ids) of the network.')
# Load from checkpoint
if args.resume:
print(
'Resuming checkpoints from finetuned model on another dataset...\n'
)
checkpoint = load_checkpoint(args.resume)
model.load_state_dict(checkpoint['state_dict'], strict=False)
else:
raise RuntimeWarning('Not using a pre-trained model.')
model = nn.DataParallel(model).cuda()
# evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
# if args.evaluate: return
# Criterion
criterion = [
TripletLoss(args.margin, args.num_instances, isAvg=True,
use_semi=True).cuda(),
TripletLoss(args.margin, args.num_instances, isAvg=True,
use_semi=True).cuda(),
]
# Optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
# training stage transformer on input images
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transformer = T.Compose([
T.Resize((args.height, args.width)),
T.RandomHorizontalFlip(),
T.ToTensor(), normalizer,
T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)
])
# # Start training
for iter_n in range(args.iteration):
if args.lambda_value == 0:
source_features = 0
else:
# get source datas' feature
source_features, _ = extract_features(model,
src_extfeat_loader,
print_freq=args.print_freq)
# synchronization feature order with src_dataset.train
source_features = torch.cat([
source_features[f].unsqueeze(0)
for f, _, _ in src_dataset.train
], 0)
# extract training images' features
print('Iteration {}: Extracting Target Dataset Features...'.format(
iter_n + 1))
target_features, tarNames = extract_features(
model, tgt_extfeat_loader, print_freq=args.print_freq)
# synchronization feature order with dataset.train
target_features = torch.cat([
target_features[f].unsqueeze(0) for f, _, _ in tgt_dataset.trainval
], 0)
target_real_label = np.asarray(
[tarNames[f].unsqueeze(0) for f, _, _ in tgt_dataset.trainval])
numTarID = len(set(target_real_label))
# calculate distance and rerank result
print('Calculating feature distances...')
target_features = target_features.numpy()
cluster = KMeans(n_clusters=numTarID, n_jobs=8, n_init=1)
# select & cluster images as training set of this epochs
print('Clustering and labeling...')
clusterRes = cluster.fit(target_features)
labels, centers = clusterRes.labels_, clusterRes.cluster_centers_
# labels = splitLowconfi(target_features,labels,centers)
# num_ids = len(set(labels))
# print('Iteration {} have {} training ids'.format(iter_n+1, num_ids))
# generate new dataset
new_dataset = []
for (fname, _, cam), label in zip(tgt_dataset.trainval, labels):
# if label==-1: continue
# dont need to change codes in trainer.py _parsing_input function and sampler function after add 0
new_dataset.append((fname, label, cam))
print('Iteration {} have {} training images'.format(
iter_n + 1, len(new_dataset)))
train_loader = DataLoader(Preprocessor(new_dataset,
root=tgt_dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size,
num_workers=4,
sampler=RandomIdentitySampler(
new_dataset, args.num_instances),
pin_memory=True,
drop_last=True)
# train model with new generated dataset
trainer = Trainer(model, criterion)
evaluator = Evaluator(model, print_freq=args.print_freq)
# Start training
for epoch in range(args.epochs):
# trainer.train(epoch, remRate=0.2+(0.6/args.iteration)*(1+iter_n)) # to at most 80%
trainer.train(epoch, train_loader, optimizer)
# test only
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
#print('co-model:\n')
#rank_score = evaluatorB.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
# Evaluate
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query,
tgt_dataset.gallery)
save_checkpoint(
{
'state_dict': model.module.state_dict(),
'epoch': epoch + 1,
'best_top1': rank_score.market1501[0],
},
True,
fpath=osp.join(args.logs_dir, 'adapted.pth.tar'))
return (rank_score.map, rank_score.market1501[0])
def get_data(name, data_dir, height, width, batch_size, num_bn_sample,
num_instances, workers):
# Datasets
if name == 'market1501':
dataset_name = 'market1501'
dataset = data_manager.init_imgreid_dataset(root=data_dir,
name=dataset_name)
dataset.images_dir = ''
train_transformer = T.Compose([
T.Random2DTranslation(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(),
])
test_transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
])
train_loader = DataLoader(Preprocessor(dataset.train,
root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
dataset.train, num_instances),
pin_memory=True,
drop_last=True)
elif name == 'market_sct' or name == 'market_sct_tran' or name == 'duke_sct' or name == 'duke_sct_tran':
dataset_name = name
dataset = data_manager.init_imgreid_dataset(
root=data_dir, name=dataset_name, num_bn_sample=num_bn_sample)
dataset.images_dir = ''
# dataset_name = name
pin_memory = True
collateFn = NormalCollateFn()
train_loader = DataLoader(
data_manager.init_datafolder(
dataset_name,
dataset.train,
TrainTransform(height, width),
),
batch_sampler=RandomIdentityCameraSampler(dataset.train,
num_instances,
batch_size),
num_workers=workers,
pin_memory=pin_memory,
collate_fn=collateFn,
)
# train_loader = DataLoader(
# data_manager.init_datafolder(dataset_name, dataset.train,
# TrainTransform(height, width),
# ),
# batch_sampler=RandomIdentityUniqueCameraSampler(dataset.train, num_instances, batch_size),
# num_workers=workers,
# pin_memory=pin_memory, collate_fn=collateFn,
# )
# Num. of training IDs
num_classes = dataset.num_train_pids
return dataset, num_classes, train_loader
def get_data(name, split_id, data_dir, height, width, batch_size,
num_instances, workers, combine_trainval):
root = osp.join(data_dir, name)
dataset = datasets.create(name, root, split_id=split_id)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_set = dataset.trainval if combine_trainval else dataset.train
num_classes = (dataset.num_trainval_ids
if combine_trainval else dataset.num_train_ids)
train_transformer = T.Compose([
T.RandomSizedRectCrop(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
])
test_transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
normalizer,
])
train_loader = DataLoader(Preprocessor(train_set,
root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
train_set, num_instances),
pin_memory=True,
drop_last=True)
train_loader_head = DataLoader(Preprocessor(
train_set,
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_head",
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
train_set, num_instances),
pin_memory=True,
drop_last=True)
train_loader_upper = DataLoader(Preprocessor(
train_set,
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_upper",
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
train_set, num_instances),
pin_memory=True,
drop_last=True)
train_loader_lower = DataLoader(Preprocessor(
train_set,
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_lower",
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
train_set, num_instances),
pin_memory=True,
drop_last=True)
val_loader = DataLoader(Preprocessor(dataset.val,
root=dataset.images_dir,
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
val_loader_head = DataLoader(Preprocessor(
dataset.val,
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_head",
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
val_loader_upper = DataLoader(Preprocessor(
dataset.val,
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_upper",
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
val_loader_lower = DataLoader(Preprocessor(
dataset.val,
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_lower",
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
test_loader = DataLoader(Preprocessor(
list(set(dataset.query) | set(dataset.gallery)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
test_loader_head = DataLoader(Preprocessor(
list(set(dataset.query) | set(dataset.gallery)),
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_head",
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
test_loader_upper = DataLoader(Preprocessor(
list(set(dataset.query) | set(dataset.gallery)),
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_upper",
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
test_loader_lower = DataLoader(Preprocessor(
list(set(dataset.query) | set(dataset.gallery)),
root="/home/bfs/zty/reid_market/examples/data/cuhk03/images_lower",
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
return dataset, num_classes, train_loader, train_loader_head, train_loader_upper, train_loader_lower,\
val_loader, val_loader_head, val_loader_upper, val_loader_lower, test_loader, test_loader_head, \
test_loader_upper, test_loader_lower
def get_data(dataset_name,
split_id,
data_dir,
batch_size,
seq_len,
seq_srd,
workers,
num_instances,
combine_trainval=True):
root = osp.join(data_dir, dataset_name)
dataset = get_sequence(dataset_name,
root,
split_id=split_id,
seq_len=seq_len,
seq_srd=seq_srd,
num_val=1,
download=True)
train_set = dataset.trainval if combine_trainval else dataset.train
num_classes = (dataset.num_trainval_ids
if combine_trainval else dataset.num_train_ids)
normalizer = seqtransforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_processor = SeqPreprocessor(train_set,
dataset,
transform=seqtransforms.Compose([
seqtransforms.RandomSizedRectCrop(
256, 128),
seqtransforms.RandomHorizontalFlip(),
seqtransforms.ToTensor(), normalizer
]))
val_processor = SeqPreprocessor(dataset.val,
dataset,
transform=seqtransforms.Compose([
seqtransforms.RectScale(256, 128),
seqtransforms.ToTensor(), normalizer
]))
test_processor = SeqPreprocessor(
list(set(dataset.query) | set(dataset.gallery)),
dataset,
transform=seqtransforms.Compose([
seqtransforms.RectScale(256, 128),
seqtransforms.ToTensor(), normalizer
]))
if num_instances > 0:
train_loader = DataLoader(train_processor,
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
train_set, num_instances),
pin_memory=True)
else:
train_loader = DataLoader(train_processor,
batch_size=batch_size,
num_workers=workers,
shuffle=True,
pin_memory=True)
val_loader = DataLoader(val_processor,
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
test_loader = DataLoader(test_processor,
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
return dataset, num_classes, train_loader, val_loader, test_loader
def get_data(name, split_id, data_dir, height, width, batch_size,
num_instances, workers, combine_trainval, make_data):
root = osp.join(data_dir, name)
if make_data:
from_dir1, from_dir2, num_eval, test, single = make_data
if test == 'test':
build_test = True
test = '_test'
elif test == 'train':
build_test = False
test = 'train'
else:
build_test = None
test = ''
to_dir = '{}{}{}{}{}'.format(from_dir1, from_dir2, num_eval, test,
single)
if single == 'single':
single = True
elif single == 'many':
single = False
else:
print('must be either single or many')
root = osp.join(data_dir, 'select')
dataset = datasets.create(name,
root,
from_dir1=from_dir1,
from_dir2=from_dir2,
to_dir=to_dir,
num_eval=int(num_eval),
make_test=build_test,
single=single,
split_id=split_id)
data_path = osp.join(root, 'datasets', to_dir)
else:
dataset = datasets.create(name, root, split_id=split_id)
data_path = osp.join(root, 'datasets', name)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_set = dataset.trainval if combine_trainval else dataset.train
num_classes = (dataset.num_trainval_ids
if combine_trainval else dataset.num_train_ids)
train_transformer = T.Compose([
T.RectCrop(height, width),
# T.RectCrop(height / 2, width / 2), # effectively blurring
# T.RectScale(int(height/2), int(width/2)),
# T.RectScale(height, width),
T.RandomSizedRectCrop(height, width, 0.4),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
])
test_transformer = T.Compose([
T.RectCrop(height, width),
# T.RectScale(int(height / 2), int(width / 2
T.RectScale(height, width),
T.ToTensor(),
normalizer,
])
train_loader = DataLoader(Preprocessor(train_set,
root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
train_set, num_instances),
pin_memory=True,
drop_last=True)
val_loader = DataLoader(
Preprocessor(
dataset.val, root=dataset.images_dir,
transform=test_transformer), # todo originally test_transformer
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
test_loader = DataLoader(Preprocessor(
list(set(dataset.query) | set(dataset.gallery)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
return dataset, num_classes, train_loader, val_loader, test_loader, data_path
def main(args):
np.random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.benchmark = True
# Redirect print to both console and log file
sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt'))
print(args)
shutil.copy(sys.argv[0], osp.join(args.logs_dir,
osp.basename(sys.argv[0])))
# Create data loaders
if args.height is None or args.width is None:
args.height, args.width = (256, 128)
dataset, num_classes, train_loader, val_loader, test_loader = \
get_data(args.dataset, args.split, args.data_dir, args.height,
args.width, args.batch_size * 8, args.workers,
)
# Create model
model = models.create("ft_net_inter",
num_classes=num_classes,
stride=args.stride)
# Load from checkpoint
start_epoch = 0
best_top1 = 0
top1 = 0
is_best = False
if args.checkpoint is not None:
if args.evaluate:
checkpoint = load_checkpoint(args.checkpoint)
param_dict = model.state_dict()
for k, v in checkpoint['state_dict'].items():
if 'model' in k:
param_dict[k] = v
model.load_state_dict(param_dict)
else:
model.model.load_param(args.checkpoint)
model = model.cuda()
# Distance metric
metric = None
# Evaluator
evaluator = Evaluator(model, use_cpu=args.use_cpu)
if args.evaluate:
print("Test:")
evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
return
train_transformer = [
T.Resize((args.height, args.width), interpolation=3),
T.RandomHorizontalFlip(),
T.Pad(10),
T.RandomCrop((args.height, args.width)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
T.RandomErasing(probability=0.5),
]
train_transformer = T.Compose(train_transformer)
for cluster_epoch in range(args.cluster_epochs):
# -------------------------Stage 1 intra camera training--------------------------
# Cluster and generate new dataset and model
cluster_result = get_intra_cam_cluster_result(model, train_loader,
args.class_number_stage1,
args.linkage)
cluster_datasets = [
datasets.create("cluster", osp.join(args.data_dir, args.dataset),
cluster_result[cam_id], cam_id)
for cam_id in cluster_result.keys()
]
cluster_dataloaders = [
DataLoader(Preprocessor(dataset.train_set,
root=dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size,
num_workers=args.workers,
shuffle=True,
pin_memory=False,
drop_last=True) for dataset in cluster_datasets
]
param_dict = model.model.state_dict()
model = models.create("ft_net_intra",
num_classes=[
args.class_number_stage1
for cam_id in cluster_result.keys()
],
stride=args.stride)
model_param_dict = model.model.state_dict()
for k, v in model_param_dict.items():
if k in param_dict.keys():
model_param_dict[k] = param_dict[k]
model.model.load_state_dict(model_param_dict)
model = model.cuda()
criterion = nn.CrossEntropyLoss().cuda()
# Optimizer
param_groups = make_params(model, args.lr, args.weight_decay)
optimizer = torch.optim.SGD(param_groups, momentum=0.9)
# Trainer
trainer = IntraCameraTrainer(model,
criterion,
warm_up_epoch=args.warm_up)
print("start training")
# Start training
for epoch in range(0, args.epochs_stage1):
trainer.train(
cluster_epoch,
epoch,
cluster_dataloaders,
optimizer,
print_freq=args.print_freq,
)
# -------------------------------------------Stage 2 inter camera training-----------------------------------
mix_rate = get_mix_rate(args.mix_rate,
cluster_epoch,
args.cluster_epochs,
power=args.decay_factor)
cluster_result = get_inter_cam_cluster_result(model,
train_loader,
args.class_number_stage2,
args.linkage,
mix_rate,
use_cpu=args.use_cpu)
cluster_dataset = datasets.create(
"cluster", osp.join(args.data_dir, args.dataset), cluster_result,
0)
cluster_dataloaders = DataLoader(
Preprocessor(cluster_dataset.train_set,
root=cluster_dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size_stage2,
num_workers=args.workers,
sampler=RandomIdentitySampler(cluster_dataset.train_set,
args.batch_size_stage2,
args.instances),
pin_memory=False,
drop_last=True)
param_dict = model.model.state_dict()
model = models.create("ft_net_inter",
num_classes=args.class_number_stage2,
stride=args.stride)
model.model.load_state_dict(param_dict)
model = model.cuda()
# Criterion
criterion_entropy = nn.CrossEntropyLoss().cuda()
criterion_triple = TripletLoss(margin=args.margin).cuda()
# Optimizer
param_groups = make_params(model,
args.lr * args.batch_size_stage2 / 32,
args.weight_decay)
optimizer = torch.optim.SGD(param_groups, momentum=0.9)
# Trainer
trainer = InterCameraTrainer(
model,
criterion_entropy,
criterion_triple,
warm_up_epoch=args.warm_up,
)
print("start training")
# Start training
for epoch in range(0, args.epochs_stage2):
trainer.train(cluster_epoch,
epoch,
cluster_dataloaders,
optimizer,
print_freq=args.print_freq)
if (cluster_epoch + 1) % 5 == 0:
evaluator = Evaluator(model, use_cpu=args.use_cpu)
top1, mAP = evaluator.evaluate(test_loader,
dataset.query,
dataset.gallery,
metric,
return_mAP=True)
is_best = top1 > best_top1
best_top1 = max(top1, best_top1)
save_checkpoint(
{
'state_dict': model.state_dict(),
'epoch': cluster_epoch + 1,
'best_top1': best_top1,
'cluster_epoch': cluster_epoch + 1,
},
is_best,
fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar'))
if cluster_epoch == (args.cluster_epochs - 1):
save_checkpoint(
{
'state_dict': model.state_dict(),
'epoch': cluster_epoch + 1,
'best_top1': best_top1,
'cluster_epoch': cluster_epoch + 1,
},
False,
fpath=osp.join(args.logs_dir, 'latest.pth.tar'))
print('\n * cluster_epoch: {:3d} top1: {:5.1%} best: {:5.1%}{}\n'.
format(cluster_epoch, top1, best_top1, ' *' if is_best else ''))
# Final test
print('Test with best model:')
checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar'))
model.load_state_dict(checkpoint['state_dict'])
best_rank1, mAP = evaluator.evaluate(test_loader,
dataset.query,
dataset.gallery,
metric,
return_mAP=True)
def main(args):
np.random.seed(args.seed) # With the seed reset (every time), the same set of numbers will appear every time.
torch.manual_seed(args.seed) # Sets the seed for generating random numbers.
cudnn.benchmark = True # This flag allows you to enable the inbuilt cudnn auto-tuner to find the best algorithm to use for your hardware. It enables benchmark mode in cudnn.
# Redirect print to both console and log file
sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt'))
print(args)
shutil.copy(sys.argv[0], osp.join(args.logs_dir,
osp.basename(sys.argv[0])))
# Create data loaders
if args.height is None or args.width is None:
args.height, args.width = (256, 128)
dataset, num_classes, train_loader, val_loader, test_loader = \
get_data(args.dataset, args.split, args.data_dir, args.height,
args.width, args.batch_size * 8, args.workers, #https://deeplizard.com/learn/video/kWVgvsejXsE#:~:text=The%20num_workers%20attribute%20tells%20the,sequentially%20inside%20the%20main%20process.
)
# Create model
model = models.create("ft_net_inter",
num_classes=num_classes, stride=args.stride)
# Load from checkpoint
start_epoch = 0
best_top1 = 0
top1 = 0
is_best = False
if args.checkpoint is not None:
if args.evaluate:
checkpoint = load_checkpoint(args.checkpoint)
param_dict = model.state_dict() # A state_dict is simply a Python dictionary object that maps each layer to its parameter tensor.
for k, v in checkpoint['state_dict'].items():
if 'model' in k:
param_dict[k] = v
model.load_state_dict(param_dict)
else:
model.model.load_param(args.checkpoint)
model = model.cuda()
# Distance metric
metric = None
# Evaluator
evaluator = Evaluator(model, use_cpu=args.use_cpu)
if args.evaluate:
print("Test:")
evaluator.evaluate(test_loader, dataset.query, dataset.gallery, metric)
return
train_transformer = [
T.Resize((args.height, args.width), interpolation=3),
T.RandomHorizontalFlip(),
T.Pad(10),
T.RandomCrop((args.height, args.width)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
T.RandomErasing(probability=0.5),
]
train_transformer = T.Compose(train_transformer)
for cluster_epoch in range(args.cluster_epochs):
# -------------------------Stage 1 intra camera training--------------------------
# Cluster and generate new dataset and model
# Divides the training set into (subsets) and according to that each camera id is there for each image
# then it forms clustering on each subset according to the pair wise similarity
# then assigning images with in each cluster with identical label
# then cross entropy loss is used
cluster_result = get_intra_cam_cluster_result(model, train_loader,
args.class_number_stage1,
args.linkage)
cluster_datasets = [
datasets.create("cluster", osp.join(args.data_dir, args.dataset),
cluster_result[cam_id], cam_id)
for cam_id in cluster_result.keys()
]
cluster_dataloaders = [
DataLoader(Preprocessor(dataset.train_set,
root=dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size,
num_workers=args.workers,
shuffle=True,
pin_memory=False,
drop_last=True) for dataset in cluster_datasets
]
param_dict = model.model.state_dict()
model = models.create("ft_net_intra",
num_classes=[
args.class_number_stage1
for cam_id in cluster_result.keys()
],
stride=args.stride)
model_param_dict = model.model.state_dict()
for k, v in model_param_dict.items():
if k in param_dict.keys():
model_param_dict[k] = param_dict[k]
model.model.load_state_dict(model_param_dict)
model = model.cuda()
criterion = nn.CrossEntropyLoss().cuda()
# Optimizer
param_groups = make_params(model, args.lr, args.weight_decay)
optimizer = torch.optim.SGD(param_groups, momentum=0.9)
# Trainer
trainer = IntraCameraTrainer(
model, criterion, warm_up_epoch=args.warm_up)
print("start training")
# Start training
for epoch in range(0, args.epochs_stage1):
trainer.train(cluster_epoch,
epoch,
cluster_dataloaders,
optimizer,
print_freq=args.print_freq,
)
# -------------------------------------------Stage 2 inter camera training-----------------------------------
mix_rate = get_mix_rate(
args.mix_rate, cluster_epoch, args.cluster_epochs, power=args.decay_factor)
cluster_result = get_inter_cam_cluster_result(
model,
train_loader,
args.class_number_stage2,
args.linkage,
mix_rate,
use_cpu=args.use_cpu)
cluster_dataset = datasets.create(
"cluster", osp.join(args.data_dir, args.dataset), cluster_result,
0)
cluster_dataloaders = DataLoader(
Preprocessor(cluster_dataset.train_set,
root=cluster_dataset.images_dir,
transform=train_transformer),
batch_size=args.batch_size_stage2,
num_workers=args.workers,
sampler=RandomIdentitySampler(cluster_dataset.train_set,
args.batch_size_stage2,
args.instances),
pin_memory=False,
drop_last=True)
param_dict = model.model.state_dict()
model = models.create("ft_net_inter",
num_classes=args.class_number_stage2,
stride=args.stride)
model.model.load_state_dict(param_dict)
model = model.cuda()
# Criterion
criterion_entropy = nn.CrossEntropyLoss().cuda()
criterion_triple = TripletLoss(margin=args.margin).cuda()
# Optimizer
param_groups = make_params(model,
args.lr * args.batch_size_stage2 / 32,
args.weight_decay)
optimizer = torch.optim.SGD(param_groups, momentum=0.9)
# Trainer
trainer = InterCameraTrainer(model,
criterion_entropy,
criterion_triple,
warm_up_epoch=args.warm_up,
)
print("start training")
# Start training
for epoch in range(0, args.epochs_stage2):
trainer.train(cluster_epoch,
epoch,
cluster_dataloaders,
optimizer,
print_freq=args.print_freq)
if (cluster_epoch + 1) % 5 == 0: # in 4th, 9th, 14th epochs, see in the output
evaluator = Evaluator(model, use_cpu=args.use_cpu)
top1, mAP = evaluator.evaluate(
test_loader, dataset.query, dataset.gallery, metric, return_mAP=True)
is_best = top1 > best_top1
best_top1 = max(top1, best_top1)
save_checkpoint(
{
'state_dict': model.state_dict(),
'epoch': cluster_epoch + 1,
'best_top1': best_top1,
'cluster_epoch': cluster_epoch + 1,
},
is_best,
fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar'))
if cluster_epoch == (args.cluster_epochs - 1):
save_checkpoint(
{
'state_dict': model.state_dict(),
'epoch': cluster_epoch + 1,
'best_top1': best_top1,
'cluster_epoch': cluster_epoch + 1,
},
False,
fpath=osp.join(args.logs_dir, 'latest.pth.tar'))
print('\n * cluster_epoch: {:3d} top1: {:5.1%} best: {:5.1%}{}\n'.
format(cluster_epoch, top1, best_top1, ' *' if is_best else ''))
# Final test
print('Test with best model:')
checkpoint = load_checkpoint(osp.join(args.logs_dir, 'model_best.pth.tar'))
model.load_state_dict(checkpoint['state_dict'])
best_rank1, mAP = evaluator.evaluate(
test_loader, dataset.query, dataset.gallery, metric, return_mAP=True)
