def get_transformer(config):
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
base_transformer = [T.ToTensor(), normalizer]
if config.training is False:
return T.Compose([T.Resize((config.height, config.width))] + base_transformer)
if config.img_translation is None:
return T.Compose([T.RandomSizedRectCrop(config.height, config.width),
T.RandomHorizontalFlip()] + base_transformer)
return T.Compose([T.RandomTranslateWithReflect(config.img_translation),
T.RandomSizedRectCrop(config.height, config.width),
T.RandomHorizontalFlip()] + base_transformer)
def get_data(name, split_id, data_dir, height, width, batch_size, 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,
shuffle=True,
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)
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)
pid_train = np.array(list(pid for _, pid, _ in train_set))
class_weight = np.array([(pid_train == i).sum()
for i in range(num_classes)])
assert np.all(class_weight != 0)
class_weight = pid_train.shape[0] / num_classes / class_weight
class_weight = torch.Tensor(class_weight).cuda()
return dataset, num_classes, class_weight, train_loader, val_loader, test_loader
def get_train_loader(dataset, height, width, batch_size, workers,
num_instances, iters, trainset=None):
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
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(probability=0.5, mean=[0.485, 0.456, 0.406])
])
train_set = dataset.train if trainset is None else trainset
rmgs_flag = num_instances > 0
if rmgs_flag:
sampler = RandomMultipleGallerySampler(train_set, num_instances)
else:
sampler = None
train_loader = IterLoader(
DataLoader(Preprocessor(train_set, root=dataset.images_dir,
transform=train_transformer, mutual=False),
batch_size=batch_size, num_workers=workers, sampler=sampler,
shuffle=not rmgs_flag, pin_memory=True, drop_last=True), length=iters)
return train_loader
def get_data(name, split_id, data_dir, height, width, batch_size,
num_instances, workers, combine_trainval, batch_id):
root = osp.join(data_dir, name)
if name == 'synthetic':
dataset = datasets.create(name,
root,
split_id=split_id,
batch_id=batch_id)
else:
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)
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)
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
def get_dataloader(dataset,data_dir,
training=False, height=256,
width=128, batch_size=64, workers=1):
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if training:
transformer = T.Compose([
T.RandomSizedRectCrop(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
])
else:
transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
normalizer,
])
data_loader = DataLoader(
Preprocessor(dataset, root=data_dir,
transform=transformer),
batch_size=batch_size, num_workers=workers,
shuffle=training, pin_memory=True, drop_last=training)
return data_loader
def get_loader(data,
root,
height=256,
width=128,
batch_size=32,
workers=0,
training=False):
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if training:
transformer = T.Compose([
T.RandomSizedRectCrop(height, width), # 对图像进行随机裁剪并缩放.
T.RandomHorizontalFlip(), # 对给定的PIL.Image进行随机水平翻转,概率为0.5,属于数据增强.
T.ToTensor(), # 将numpy图像转换为torch图像.
normalizer,
])
else:
transformer = T.Compose([
T.RectScale(height, width), # 缩放图像.
T.ToTensor(),
normalizer,
])
batch_size = batch_size * 8
data_loader = DataLoader(Preprocessor(data,
root=root,
transform=transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=training,
pin_memory=True)
return data_loader
def get_dataloader(self, dataset, training=False) :
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if training:
transformer = T.Compose([
T.RandomSizedRectCrop(self.data_height, self.data_width),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
])
batch_size = self.batch_size
else:
transformer = T.Compose([
T.RectScale(self.data_height, self.data_width),
T.ToTensor(),
normalizer,
])
batch_size = self.eval_bs
data_loader = DataLoader(
Preprocessor(dataset, root=self.data_dir,
transform=transformer, is_training=training, max_frames=self.max_frames),
batch_size=batch_size, num_workers=self.data_workers,
shuffle=training, pin_memory=True, drop_last=training)
current_status = "Training" if training else "Test"
print("create dataloader for {} with batch_size {}".format(current_status, batch_size))
return data_loader
def get_data(dataname,
data_dir,
height,
width,
batch_size,
combine_all=False,
min_size=0.,
max_size=0.8,
workers=8,
test_batch=64):
root = osp.join(data_dir, dataname)
dataset = datasets.create(dataname, root, combine_all=combine_all)
num_classes = dataset.num_train_ids
train_transformer = T.Compose([
T.RandomHorizontalFlip(),
T.Resize((height, width), interpolation=3),
T.RandomOcclusion(min_size, max_size),
T.ToTensor(),
])
test_transformer = T.Compose([
T.Resize((height, width), interpolation=3),
T.ToTensor(),
])
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,
shuffle=True,
pin_memory=True,
drop_last=True)
query_loader = DataLoader(Preprocessor(dataset.query,
root=osp.join(
dataset.images_dir,
dataset.query_path),
transform=test_transformer),
batch_size=test_batch,
num_workers=32,
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=test_batch,
num_workers=32,
shuffle=False,
pin_memory=True)
return dataset, num_classes, train_loader, query_loader, gallery_loader
def get_data(name, data_dir, height, width, batch_size, workers):
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.RectScale(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
])
test_transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
normalizer,
])
train_loader = DataLoader(Preprocessor(dataset.train,
root=osp.join(
dataset.images_dir,
dataset.train_path),
transform=train_transformer,
random_mask=False),
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.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.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(name, data_dir, height, width, ratio, batch_size, workers, num_instances=8):
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])
listnormalizer = T.ListNormalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
num_classes = dataset.num_train_ids + 1 # plus 1 more label for the zero-padded feature
train_transformer = T.Compose([
T.RectScale(height, width),
T.RandomHorizontalFlip(),
T.RandomVerticalCropCont(height,width),
T.ListToTensor(),
listnormalizer,
])
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),
# shuffle=True,
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(name,
split_id,
data_dir,
height,
width,
crop_height,
crop_width,
batch_size,
caffe_sampler=False,
workers=4):
root = osp.join(data_dir, name)
dataset = datasets.create(name, root, split_id=split_id)
train_set = dataset.trainval
num_classes = dataset.num_trainval_ids
# transforms
train_transformer = T.Compose([
T.RectScale(height, width),
# T.CenterCrop((crop_height, crop_width)),
T.RandomHorizontalFlip(),
T.ToTensor(),
T.RGB_to_BGR(),
T.NormalizeBy(255),
])
test_transformer = T.Compose([
T.RectScale(height, width),
# T.CenterCrop((crop_height, crop_width)),
T.ToTensor(),
T.RGB_to_BGR(),
T.NormalizeBy(255),
])
# dataloaders
sampler = caffeSampler(train_set, name, batch_size=batch_size, root=dataset.images_dir) if caffe_sampler else \
RandomIdentitySampler(train_set, 10) #TODO
train_loader = DataLoader(Preprocessor(train_set,
root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=sampler,
pin_memory=True,
drop_last=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, test_loader
def get_data(dataset_name, split_id, data_dir, batch_size, workers,
num_instances, combine_trainval=False):
root = osp.join(data_dir, dataset_name)
dataset = get_dataset(dataset_name, root,
split_id=split_id, num_val=1, download=True)
normalizer = transforms.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_processor = Preprocessor(train_set, root=dataset.images_dir,
transform=transforms.Compose([
transforms.RandomSizedRectCrop(256, 128),
transforms.RandomHorizontalFlip(),
transforms.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(
Preprocessor(dataset.val, root=dataset.images_dir,
transform=transforms.Compose([
transforms.RectScale(256, 128),
transforms.ToTensor(),
normalizer,
])),
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=transforms.Compose([
transforms.RectScale(256, 128),
transforms.ToTensor(),
normalizer,
])),
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):
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])
# load train_set, query_set, gallery_set
mt_train_set = dataset.train
mt_num_classes = dataset.num_train_tids_sub
query_set = dataset.query
gallery_set = dataset.gallery
train_transformer = T.Compose([
T.RandomSizedRectCrop(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(), normalizer
])
test_transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
normalizer,
])
# Random ID
mt_train_set = flatten_dataset(mt_train_set)
num_task = len(
mt_num_classes) # num_task equals camera number, each camera is a task
mt_train_loader = DataLoader(
Preprocessor_Image(mt_train_set,
root=dataset.dataset_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentitySampler(
mt_train_set, num_instances,
num_task), # Here is different between softmax_loss
pin_memory=True,
drop_last=True)
query_set = flatten_dataset(query_set)
gallery_set = flatten_dataset(gallery_set)
test_set = list(set(query_set) | set(gallery_set))
test_loader = DataLoader(Preprocessor_Image(test_set,
root=dataset.dataset_dir,
transform=test_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=False,
pin_memory=True)
return mt_train_loader, mt_num_classes, test_loader, query_set, gallery_set
def get_data(dataname, data_dir, height, width, batch_size, camstyle=0, re=0, workers=8):
root = osp.join(data_dir, dataname)
dataset = datasets.create(dataname, 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.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
T.RandomErasing(EPSILON=re),
])
test_transformer = T.Compose([
T.Resize((height, width), interpolation=3),
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,
shuffle=True, pin_memory=True, drop_last=True)
query_loader = DataLoader(
Preprocessor(dataset.query,
root=osp.join(dataset.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.images_dir, dataset.gallery_path), transform=test_transformer),
batch_size=batch_size, num_workers=workers,
shuffle=False, pin_memory=True)
if camstyle <= 0:
camstyle_loader = None
else:
camstyle_loader = DataLoader(
Preprocessor(dataset.camstyle, root=osp.join(dataset.images_dir, dataset.camstyle_path),
transform=train_transformer),
batch_size=camstyle, num_workers=workers,
shuffle=True, pin_memory=True, drop_last=True)
return dataset, num_classes, train_loader, query_loader, gallery_loader, camstyle_loader
def get_data(name, split_id, data_dir, height, width, batch_size, workers,
combine_trainval, np_ratio):
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
train_transformer = T.Compose([
T.RandomSizedRectCrop(height, width),
T.RandomSizedEarser(),
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),
sampler=RandomPairSampler(
train_set, neg_pos_ratio=np_ratio),
batch_size=batch_size,
num_workers=workers,
pin_memory=False)
val_loader = DataLoader(Preprocessor(dataset.val,
root=dataset.images_dir,
transform=test_transformer),
batch_size=batch_size,
num_workers=0,
shuffle=False,
pin_memory=False)
test_loader = DataLoader(Preprocessor(
list(set(dataset.query) | set(dataset.gallery)),
root=dataset.images_dir,
transform=test_transformer),
batch_size=batch_size,
num_workers=0,
shuffle=False,
pin_memory=False)
return dataset, train_loader, val_loader, test_loader
def get_data(data_dir, source, target, height, width, 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)
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)
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, target_train_loader, query_loader, gallery_loader
def get_data(split_id, data_dir, height, width, batchSize, workers, combine_trainval, train_list, \
val_list, query_list, gallery_list):
root = data_dir
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]) # RGB imagenet
train_set = train_list + val_list if combine_trainval else train_list # a list
train_transformer = T.Compose([
T.RectScale(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(), # [0, 255] to [0.0, 1.0]
normalizer, # normalize each channel of the input
])
test_transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
normalizer,
])
train_loader = DataLoader(
Preprocessor(train_set, root=root, transform=train_transformer),
batch_size=batchSize,
num_workers=workers,
sampler=RandomSampler(train_set),
# shuffle=True,
pin_memory=True,
drop_last=True)
val_loader = DataLoader(Preprocessor(val_list,
root=root,
transform=test_transformer),
batch_size=batchSize,
num_workers=workers,
shuffle=False,
pin_memory=True)
test_loader = DataLoader(Preprocessor(
list(set(query_list) | set(gallery_list)),
root=root,
transform=test_transformer),
batch_size=batchSize,
num_workers=workers,
shuffle=False,
pin_memory=True)
return train_loader, val_loader, test_loader
def get_dataloader(self, dataset, training=False):
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if training: # import transforms as T
transformer = T.Compose([
T.RandomSizedRectCrop(
self.data_height,
self.data_width), # data_height = 256 data_width = 128
T.RandomHorizontalFlip(), # 随机水平翻转
T.ToTensor(
), # Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor.
normalizer, # normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225])
])
batch_size = self.batch_size # batch_size = 16
else:
transformer = T.Compose([
T.RectScale(self.data_height,
self.data_width), # RectScale():三角缩放(?)
T.ToTensor(
), # Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor.
normalizer, # normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
]) # std=[0.229, 0.224, 0.225])
batch_size = self.eval_bs # batch_size = 64
data_dir = self.data_dir # data_dir = dataset_all.image_dir
data_loader = DataLoader( # DataLoader()
Preprocessor(
dataset,
root=data_dir,
num_samples=self.
frames_per_video, # root = dataset_all.image_dir num_samples = 1
transform=transformer,
is_training=training,
max_frames=self.max_frames
), # transform = T.compose()返回值 is_training = False max_frames = 900
batch_size=batch_size,
num_workers=self.
data_workers, # batch_size = 16 data_workers = 6
shuffle=training,
pin_memory=True,
drop_last=training) # shuffle = True drop_last = True
current_status = "Training" if training else "Testing" # current_status = 'Training'
print("Create dataloader for {} with batch_size {}".format(
current_status,
batch_size)) # Create dataloader for Training with batch_size 16
return data_loader
def get_data(name, split_id, data_dir, big_height, big_width, target_height,
target_width, batch_size, num_instances, workers,
combine_trainval):
root = osp.join(data_dir, name)
dataset = datasets.create(name, root, split_id=split_id, download=True)
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.ResizeRandomCrop(big_height, big_width, target_height, target_width),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
T.RandomErasing(0.5),
])
test_transformer = T.Compose([
T.RectScale(target_height, target_width),
T.ToTensor(),
normalizer,
])
train_loader = DataLoader(
Attribute_Preprocessor(train_set,
root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
sampler=RandomIdentityAttributeSampler(train_set, num_instances),
pin_memory=True,
drop_last=True)
test_loader = DataLoader(Attribute_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, test_loader
def get_data(name, split_id, data_dir, height, width, batch_size, workers,
combine_trainval):
root = os.path.join(data_dir, name)
dataset = datasets.create(name, root, split_id=split_id)
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(),
ColorHistograms()
])
test_transformer = t.Compose(
[t.RectScale(height, width),
ColorHistograms()])
train_loader = DataLoader(Preprocessor(train_set,
root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size,
num_workers=workers,
shuffle=True,
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)
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
def get_data(sourceName, mteName, split_id, data_dir, height, width,
batch_size, workers, combine,num_instances=8):
root = osp.join(data_dir, sourceName)
rootMte = osp.join(data_dir, mteName)
sourceSet = datasets.create(sourceName, root, num_val=0.1, split_id=split_id)
mteSet = datasets.create(mteName, rootMte, num_val=0.1, split_id=split_id)
num_classes = sourceSet.num_trainval_ids if combine else sourceSet.num_train_ids
class_meta = mteSet.num_trainval_ids if combine else mteSet.num_train_ids
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
test_transformer = T.Compose([
T.RectScale(height, width),
T.ToTensor(),
normalizer,
])
defen_train_transformer = T.Compose([
Resize((height, width)),
T.RandomSizedRectCrop(height, width),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)
])
meta_train_loader = DataLoader(
Preprocessor(sourceSet.trainval, root=sourceSet.images_dir,
transform=defen_train_transformer),
batch_size=batch_size, num_workers=workers,
sampler=RandomIdentitySampler(sourceSet.trainval, num_instances),
pin_memory=True, drop_last=True)
meta_test_loader=DataLoader(
Preprocessor(mteSet.trainval, root=mteSet.images_dir,
transform=defen_train_transformer),
batch_size=batch_size, num_workers=workers,
sampler=RandomIdentitySampler(mteSet.trainval, num_instances),
pin_memory=True, drop_last=True)
sc_test_loader = DataLoader(
Preprocessor(list(set(sourceSet.query) | set(sourceSet.gallery)),
root=sourceSet.images_dir, transform=test_transformer),
batch_size=batch_size, num_workers=workers,
shuffle=False, pin_memory=True)
return sourceSet, mteSet, num_classes, meta_train_loader, meta_test_loader,sc_test_loader,class_meta
def get_data(name, data_dir, height, width, batch_size, workers, num_instances, iters=200):
root = osp.join(data_dir, name)
dataset = datasets.create(name, root)
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_set = dataset.train
num_classes = dataset.num_train_pids
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
])
test_transformer = T.Compose([
T.Resize((height, width), interpolation=3),
T.ToTensor(),
normalizer
])
rmgs_flag = num_instances > 0
if rmgs_flag:
sampler = RandomMultipleGallerySampler(train_set, num_instances)
else:
sampler = None
train_loader = IterLoader(
DataLoader(Preprocessor(train_set, root=dataset.images_dir,
transform=train_transformer),
batch_size=batch_size, num_workers=workers, sampler=sampler,
shuffle=not rmgs_flag, pin_memory=True, drop_last=True), length=iters)
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, test_loader
def get_data(data_dir, source, target, height, width, batch_size, num_instance=2, 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.Resize((256, 128), interpolation=3),
T.Pad(10),
T.RandomCrop((256,128)),
T.RandomHorizontalFlip(0.5),
T.RandomRotation(5),
T.ToTensor(),
normalizer,
])
test_transformer = T.Compose([
T.Resize((256, 128), interpolation=3),
T.ToTensor(),
normalizer,
])
source_train_loader = DataLoader(
Preprocessor_occluded(dataset.source_train, root=osp.join(dataset.source_images_dir, dataset.source_train_path),
transform=train_transformer, train=True),
batch_size=batch_size, num_workers=workers,
sampler=IdentitySampler(dataset.source_train, num_instance),
pin_memory=True, drop_last=True)
query_loader = DataLoader(
Preprocessor_occluded(dataset.query,
root=osp.join(dataset.target_images_dir, dataset.query_path), transform=test_transformer),
batch_size=42, num_workers=workers,
shuffle=False, pin_memory=True)
gallery_loader = DataLoader(
Preprocessor_occluded(dataset.gallery,
root=osp.join(dataset.target_images_dir, dataset.gallery_path), transform=test_transformer),
batch_size=42, num_workers=workers,
shuffle=False, pin_memory=True)
return dataset, num_classes, source_train_loader, query_loader, gallery_loader
def get_dataloader(self, dataset, training=False):
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if training:
transformer = T.Compose([
T.RandomSizedRectCrop(self.data_height, self.data_width),
T.RandomHorizontalFlip(),
T.ToTensor(), normalizer,
T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)
])
else:
transformer = T.Compose([
T.Resize((self.data_height, self.data_width)),
T.ToTensor(),
normalizer,
])
if training and self.num_classes == 0:
data_loader = DataLoader(Preprocessor(dataset,
root='',
transform=transformer),
batch_size=self.batch_size,
num_workers=self.data_workers,
sampler=RandomIdentitySampler(
dataset, self.num_instances),
pin_memory=True,
drop_last=training)
else:
data_loader = DataLoader(Preprocessor(dataset,
root='',
transform=transformer),
batch_size=self.batch_size,
num_workers=self.data_workers,
shuffle=training,
pin_memory=True,
drop_last=training)
current_status = "Training" if training else "Test"
print("create dataloader for {} with batch_size {}".format(
current_status, self.batch_size))
return data_loader
def __init__(self,
dataset,
root=None,
with_pose=False,
pose_root=None,
pid_imgs=None,
height=256,
width=128,
pose_aug='no',
transform=None):
super(Preprocessor, self).__init__()
self.dataset = dataset
self.root = root
self.with_pose = with_pose
self.pose_root = pose_root
self.pid_imgs = pid_imgs
self.height = height
self.width = width
self.pose_aug = pose_aug
normalizer = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if transform == None:
self.transform = transforms.Compose([
transforms.RectScale(height, width),
transforms.RandomSizedEarser(),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalizer,
])
else:
self.transform = transform
self.transform_p = transforms.Compose([
transforms.RectScale(height, width),
transforms.ToTensor(),
normalizer,
])
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 target domain (direct transfer):"
)
evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
if args.evaluate:
return
# Criterion
criterion = [
TripletLoss(args.margin, args.num_instances).cuda(),
TripletLoss(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
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 = []
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)
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(),
SortedTripletLoss(args.margin, isAvg=True).cuda(),
# HoughTripletLoss(args.margin, args.num_instances, isAvg=True, use_semi=True).cuda(),
# None,
None, 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)
st_model = ST_Model(tgt_dataset.meta['num_cameras'])
same = None
# train_loader2 = None
best_mAP = 0
# # 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])
target_features = target_features.numpy()
rerank_dist = re_ranking(source_features, target_features, lambda_value=args.lambda_value)
ranking = np.argsort(rerank_dist)[:, 1:]
if iter_n != 0:
st_dist = np.zeros(rerank_dist.shape)
for i, (_, _, c1, t1) in enumerate(tgt_dataset.trainval):
for j, (_, _, c2, t2) in enumerate(tgt_dataset.trainval):
if not same.in_peak(c1, c2, t1, t2, 0.25):
st_dist[i, j] = 1
rerank_dist = rerank_dist + st_dist * 10
# if iter_n > 0:
# rerank_dist = st_model.apply(rerank_dist, tgt_dataset.trainval, tgt_dataset.trainval)
cluster = HDBSCAN(metric='precomputed', min_samples=10)
# select & cluster images as training set of this epochs
clusterRes = cluster.fit(rerank_dist.astype(np.float64))
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)))
# learn ST model
# if iter_n % 2 == 0:
# if iter_n == 0:
# cluster = HDBSCAN(metric='precomputed', min_samples=10)
# # select & cluster images as training set of this epochs
# clusterRes = cluster.fit(rerank_dist.astype(np.float64))
# 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)))
# same, _ = st_model.fit(new_dataset)
# st_model.fit(tgt_dataset.trainval)
same, _ = st_model.fit(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
)
def filter(i, j):
_, _, c1, t1 = tgt_dataset.trainval[i]
_, _, c2, t2 = tgt_dataset.trainval[j]
return st_model.val(c1, c2, t1, t2) > 0.01
# if iter_n == 0:
# ranking = np.argsort(rerank_dist)[:, 1:]
# dukemtmc
# cluster_size = 23.535612535612536
# market1501
cluster_size = 17.22503328894807
must_conn = int(cluster_size / 2)
might_conn = int(cluster_size * 2)
length = len(tgt_dataset.trainval)
pos = [[] for _ in range(length)]
neg = [[] for _ in range(length)]
for i in range(length):
for j_ in range(might_conn):
j = ranking[i][j_]
if j_ < must_conn and i in ranking[j][:must_conn]:
pos[i].append(j)
elif i in ranking[j][:might_conn] and filter(i, j):
pos[i].append(j)
else:
neg[i].append(j)
# pos[i] = pos[i][-1:]
# neg[i] = neg[i][:1]
SP, SF, DP, DF = 0, 0, 0, 0
for i in range(length):
for j in pos[i]:
if tgt_dataset.trainval[i][1] == tgt_dataset.trainval[j][1]:
SP += 1
else:
SF += 1
for j in neg[i]:
if tgt_dataset.trainval[i][1] == tgt_dataset.trainval[j][1]:
DP += 1
else:
DF += 1
print('stat: %.1f %.1f %.3f, %.3f' % ((SP + SF) / length, (DP + DF) / length, SP / (SP + SF), DF / (DP + DF)))
train_loader2 = DataLoader(
Preprocessor(tgt_dataset.trainval, root=tgt_dataset.images_dir, transform=train_transformer),
batch_size=args.batch_size, num_workers=4,
# sampler=RandomIdentitySampler(new_dataset, args.num_instances),
# shuffle=True,
sampler=TripletSampler(tgt_dataset.trainval, pos, neg),
pin_memory=True, drop_last=True
)
# learn visual model
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)
# trainer = HoughTrainer(model, st_model, train_loader, criterion, classOptimizer)
trainer = ClassificationTrainer(model, train_loader, criterion, classOptimizer)
trainer2 = Trainer(model, train_loader2, criterion, optimizer)
for epoch in range(args.epochs):
trainer.train(epoch)
if epoch % 8 == 0:
trainer2.train(epoch)
# evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
rank_score = evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
if rank_score.map > best_mAP:
best_mAP = rank_score.map
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'))
# 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],
}, False, 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
# Redirect print to both console and log file
if not args.evaluate:
sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt'))
# 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)
train, val, trainval = [], [], []
numbers = [0, 0, 0]
dataset_cuhk03 = merge('cuhk03', train, val, trainval, numbers, args.data_dir, args.split)
dataset_market1501 = merge('market1501', train, val, trainval, numbers, args.data_dir, args.split)
merge('cuhksysu', train, val, trainval, numbers, args.data_dir, args.split)
merge('mars', train, val, trainval, numbers, args.data_dir, args.split)
num_train_ids, num_val_ids, num_trainval_ids = numbers
assert num_val_ids == dataset_cuhk03.num_val_ids + dataset_market1501.num_val_ids
print("============================================")
print("JSTL dataset loaded")
print(" subset | # ids | # images")
print(" ---------------------------")
print(" train | {:5d} | {:8d}"
.format(num_train_ids, len(train)))
print(" val | {:5d} | {:8d}"
.format(num_val_ids, len(val)))
print(" trainval | {:5d} | {:8d}"
.format(num_trainval_ids, len(trainval)))
query_cuhk03, gallery_cuhk03 = dataset_cuhk03.query, dataset_cuhk03.gallery
query_market1501, gallery_market1501 = dataset_market1501.query, dataset_market1501.gallery
normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_set = trainval if args.combine_trainval else train
num_classes = (num_trainval_ids if args.combine_trainval
else num_train_ids)
train_transformer = T.Compose([
T.RandomSizedRectCrop(args.height, args.width),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
])
test_transformer = T.Compose([
T.RectScale(args.height, args.width),
T.ToTensor(),
normalizer,
])
train_loader = DataLoader(
Preprocessor(train_set, root=args.data_dir,
transform=train_transformer),
batch_size=args.batch_size, num_workers=args.workers,
sampler=RandomIdentitySampler(train_set, args.num_instances),
pin_memory=True, drop_last=True)
val_loader = DataLoader(
Preprocessor(val, root=args.data_dir,
transform=test_transformer),
batch_size=args.batch_size, num_workers=args.workers,
shuffle=False, pin_memory=True)
test_loader_cuhk03 = DataLoader(
Preprocessor(list(set(query_cuhk03) | set(gallery_cuhk03)),
root=dataset_cuhk03.images_dir, transform=test_transformer),
batch_size=args.batch_size, num_workers=args.workers,
shuffle=False, pin_memory=True)
test_loader_market1501 = DataLoader(
Preprocessor(list(set(query_market1501) | set(gallery_market1501)),
root=dataset_market1501.images_dir, transform=test_transformer),
batch_size=args.batch_size, num_workers=args.workers,
shuffle=False, pin_memory=True)
# Create model
# Hacking here to let the classifier be the last feature embedding layer
# Net structure: avgpool -> FC(1024) -> FC(args.features)
model = models.create(args.arch, num_features=1024,
dropout=args.dropout, num_classes=args.features)
# Load from checkpoint
start_epoch = best_top1 = 0
if args.resume:
checkpoint = load_checkpoint(args.resume)
model.load_state_dict(checkpoint['state_dict'])
start_epoch = checkpoint['epoch']
best_top1 = checkpoint['best_top1']
print("=> Start epoch {} best top1 {:.1%}"
.format(start_epoch, best_top1))
model = nn.DataParallel(model).cuda()
# Distance metric
metric = DistanceMetric(algorithm=args.dist_metric)
# Evaluator
evaluator = Evaluator(model)
if args.evaluate:
metric.train(model, train_loader)
print("Validation:")
evaluator.evaluate(val_loader, val, val, metric)
print("Test(cuhk03):")
evaluator.evaluate(test_loader_cuhk03, query_cuhk03, gallery_cuhk03, metric)
print("Test(market1501):")
evaluator.evaluate(test_loader_market1501, query_market1501, gallery_market1501, metric)
return
# Criterion
criterion = TripletLoss(margin=args.margin).cuda()
# Optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr,
weight_decay=args.weight_decay)
# Trainer
trainer = Trainer(model, criterion)
# Schedule learning rate
def adjust_lr(epoch):
lr = args.lr if epoch <= 100 else \
args.lr * (0.001 ** ((epoch - 100) / 50.0))
for g in optimizer.param_groups:
g['lr'] = lr * g.get('lr_mult', 1)
# Start training
for epoch in range(start_epoch, args.epochs):
adjust_lr(epoch)
trainer.train(epoch, train_loader, optimizer)
if epoch < args.start_save:
continue
top1 = evaluator.evaluate(val_loader, val, val)
is_best = top1 > best_top1
best_top1 = max(top1, best_top1)
save_checkpoint({
'state_dict': model.module.state_dict(),
'epoch': epoch + 1,
'best_top1': best_top1,
}, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar'))
print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'.
format(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.module.load_state_dict(checkpoint['state_dict'])
metric.train(model, train_loader)
print("Test(cuhk03):")
evaluator.evaluate(test_loader_cuhk03, query_cuhk03, gallery_cuhk03, metric)
print("Test(market1501):")
evaluator.evaluate(test_loader_market1501, query_market1501, gallery_market1501, metric)
def main(args):
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_devices
np.random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.benchmark = True
# Redirect print to both console and log file
if not args.evaluate:
sys.stdout = Logger(osp.join(args.logs_dir, 'log.txt'))
# 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 last feature embedding layer
# Net structure: avgpool -> FC(2048) -> FC(args.features)
num_class = 0
if args.src_dataset == 'dukemtmc':
model = models.create(args.arch, num_classes=num_class, num_split=args.num_split, cluster=args.dce_loss) #duke
elif args.src_dataset == 'market1501':
model = models.create(args.arch, num_classes=num_class, num_split=args.num_split, cluster=args.dce_loss)
else:
raise RuntimeError('Please specify the number of classes (ids) of the network.')
# Load from checkpoint
start_epoch = best_top1 = 0
if args.resume:
print('Resuming checkpoints from finetuned model on another dataset...\n')
checkpoint = load_checkpoint(args.resume)
model.load_state_dict(checkpoint, 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:")
best_top1 = evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)
if args.evaluate:
return
# Criterion
criterion = []
criterion.append(TripletLoss(margin=args.margin,num_instances=args.num_instances).cuda())
criterion.append(TripletLoss(margin=args.margin,num_instances=args.num_instances).cuda())
#multi lr
base_param_ids = set(map(id, model.module.base.parameters()))
new_params = [p for p in model.parameters() if
id(p) not in base_param_ids]
param_groups = [
{'params': model.module.base.parameters(), 'lr_mult': 1.0},
{'params': new_params, 'lr_mult': 1.0}]
# Optimizer
optimizer = torch.optim.SGD(param_groups, lr=args.lr,
momentum=0.9, weight_decay=args.weight_decay)
##### adjust lr
def adjust_lr(epoch):
if epoch <= 7:
lr = args.lr
elif epoch <=14:
lr = 0.3 * args.lr
else:
lr = 0.1 * args.lr
for g in optimizer.param_groups:
g['lr'] = lr * g.get('lr_mult', 1)
##### 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([
Resize((args.height,args.width)),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalizer,
T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)
])
# Start training
iter_nums = args.iteration
start_epoch = args.start_epoch
cluster_list = []
top_percent = args.rho
EF = 100 // iter_nums + 1
eug = None
for iter_n in range(start_epoch, iter_nums):
#### get source datas' feature
if args.load_dist and iter_n == 0:
dist = pickle.load(open('dist' + str(args.num_split) + '.pkl', 'rb'))
euclidean_dist_list = dist['euclidean']
rerank_dist_list = dist['rerank']
else:
source_features, _ = extract_features(model, src_extfeat_loader, for_eval=False)
if isinstance(source_features[src_dataset.trainval[0][0]], list):
len_f = len(source_features[src_dataset.trainval[0][0]])
source_features = [torch.cat([source_features[f][i].unsqueeze(0) for f, _, _ in src_dataset.trainval], 0) for i in range(len_f)]
else:
source_features = torch.cat([source_features[f].unsqueeze(0) for f, _, _ in src_dataset.trainval], 0) # synchronization feature order with s_dataset.trainval
#### extract training images' features
print('Iteration {}: Extracting Target Dataset Features...'.format(iter_n+1))
target_features, _ = extract_features(model, tgt_extfeat_loader, for_eval=False)
if isinstance(target_features[tgt_dataset.trainval[0][0]], list):
len_f = len(target_features[tgt_dataset.trainval[0][0]])
target_features = [torch.cat([target_features[f][i].unsqueeze(0) for f, _, _ in tgt_dataset.trainval], 0) for i in range(len_f)]
else:
target_features = torch.cat([target_features[f].unsqueeze(0) for f, _, _ in tgt_dataset.trainval], 0) # synchronization feature order with dataset.trainval
#### calculate distance and rerank result
print('Calculating feature distances...')
# target_features = target_features.numpy()
euclidean_dist_list, rerank_dist_list = compute_dist(
source_features, target_features, lambda_value=args.lambda_value, no_rerank=args.no_rerank, num_split=args.num_split) # lambda=1 means only source dist
del target_features
del source_features
labels_list, cluster_list = generate_selflabel(
euclidean_dist_list, rerank_dist_list, iter_n, args, cluster_list)
#### generate new dataset
train_loader = generate_dataloader(tgt_dataset, labels_list, train_transformer, iter_n, args)
if iter_n == 5:
u_data, l_data = updata_lable(tgt_dataset, labels_list[0], args.tgt_dataset, sample=args.sample)
eug = EUG(model_name=args.arch, batch_size=args.batch_size, mode=args.mode, num_classes=num_class,
data_dir=args.data_dir, l_data=l_data, u_data=u_data, print_freq=args.print_freq,
save_path=args.logs_dir, pretrained_model=model, rerank=True)
eug.model = model
if eug is not None:
nums_to_select = int(min((iter_n + 1) * int(len(u_data) // (iter_nums)), len(u_data)))
pred_y, pred_score = eug.estimate_label()
print('This is running {} with EF= {}%, step {}:\t Nums_to_be_select {}, \t Logs-dir {}'.format(
args.mode, EF, iter_n+1, nums_to_select, args.logs_dir
))
selected_idx = eug.select_top_data(pred_score, nums_to_select)
new_train_data = eug.generate_new_train_data(selected_idx, pred_y)
eug_dataloader = eug.get_dataloader(new_train_data, training=True)
top1 = iter_trainer(model, tgt_dataset, train_loader, eug_dataloader, test_loader, optimizer,
criterion, args.epochs, args.logs_dir, args.print_freq, args.lr)
eug.model = model
del train_loader
# del eug_dataloader
else:
top1 = iter_trainer(model, tgt_dataset, train_loader, None, test_loader, optimizer,
criterion, args.epochs, args.logs_dir, args.print_freq, args.lr)
del train_loader
is_best = top1 > best_top1
best_top1 = max(top1, best_top1)
save_checkpoint({
'state_dict': model.module.state_dict(),
'epoch': iter_n + 1,
'best_top1': best_top1,
# 'num_ids': num_ids,
}, is_best, fpath=osp.join(args.logs_dir, 'checkpoint.pth.tar'))
print('\n * Finished epoch {:3d} top1: {:5.1%} best: {:5.1%}{}\n'.
format(iter_n+1, top1, best_top1, ' *' if is_best else ''))
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)
query = dataset.query
query_ids = [pid for _, pid, _ in query]
query_fnames = [fname for fname, _, _ in query]
query_cams = [cam for _, _, cam in query]
query_ids_unique = list(set(query_ids))
query_fnames_new, query_ids_new, query_cams_new = [], [], []
gallery_fnames_new, gallery_ids_new, gallery_cams_new = [], [], []
for k in query_ids_unique:
idx = query_ids.index(k)
query_ids_new.append(k)
query_fnames_new.append(query_fnames[idx])
query_cams_new.append(query_cams[idx])
new_idx = idx + 1
while query_cams[idx] == query_cams[new_idx]:
new_idx += 1
gallery_ids_new.append(k)
gallery_fnames_new.append(query_fnames[new_idx])
gallery_cams_new.append(query_cams[new_idx])
query_num = len(query_ids_unique)
query_test_num = 100 # 2 GPU
split_num = query_num // query_test_num
test_set = []
tmp = []
for k in range(split_num):
for i in range(2):
for j in range(k * query_test_num, (k + 1) * query_test_num):
if i == 0:
tmp.extend((query_fnames_new[j], query_ids_new[j],
query_cams_new[j]))
else:
tmp.extend((gallery_fnames_new[j], gallery_ids_new[j],
gallery_cams_new[j]))
test_set.append(tmp)
tmp = []
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)
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)
"""
test_loader = DataLoader(
Preprocessor(test_set, root=dataset.images_dir,
transform=test_transformer),
batch_size=2*query_test_num, 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
