def test_timer_init():
timer = mmcv.Timer(start=False)
assert not timer.is_running
timer.start()
assert timer.is_running
timer = mmcv.Timer()
assert timer.is_running
def test_timer_context(capsys):
with mmcv.Timer():
time.sleep(1)
out, _ = capsys.readouterr()
assert abs(float(out) - 1) < 1e-2
with mmcv.Timer(print_tmpl='time: {:.1f}s'):
time.sleep(1)
out, _ = capsys.readouterr()
assert out == 'time: 1.0s\n'
def test_timer_run():
timer = mmcv.Timer()
time.sleep(1)
assert abs(timer.since_start() - 1) < 1e-2
time.sleep(1)
assert abs(timer.since_last_check() - 1) < 1e-2
assert abs(timer.since_start() - 2) < 1e-2
timer = mmcv.Timer(False)
with pytest.raises(mmcv.TimerError):
timer.since_start()
with pytest.raises(mmcv.TimerError):
timer.since_last_check()
def evaluate(results, evals, topk=(1, 5, 10)):
clips = accumulate_by_key(results, 'clip_ele_embed')
syns = accumulate_by_key(results, 'syn_ele_embed')
clip_len = accumulate_by_key(results, 'clip_ele_len')
syn_len = accumulate_by_key(results, 'syn_ele_len')
if 'basic' in evals:
if clip_len is None:
score_basic = clamp_cdist(clips, syns)
else:
score_basic = get_score_cosine_similarity(clips, syns,
clip_len.tolist(),
syn_len.tolist())
stat = calc_stat(score_basic, topk, 'Basic')
print_stat(stat)
## Eval optim
for eval_method in evals:
if eval_method == 'basic':
continue
with mmcv.Timer('Evaluating {}...'.format(eval_method)):
seq_score = clamp_cdist(clips, syns)
if eval_method == 'efm':
title = 'EFW'
score_optim, _, _ = get_score_efw(seq_score, clips, syns,
clip_len.tolist(),
syn_len.tolist())
elif eval_method == 'bm':
title = 'BM'
score_optim, _, _ = get_score_bm(seq_score, clips, syns,
clip_len.tolist(),
syn_len.tolist())
stat = calc_stat(score_optim, topk, title)
print_stat(stat)
def main():
args = parse_args()
for beta in [0.005, 0.01]:
if beta == 0.005:
cityscapes_path = '/home/wangyu/env/mmdetection_train/mmdetection/data/foggy_cityscapes_weak'
elif beta == 0.01:
cityscapes_path = '/home/wangyu/env/mmdetection_train/mmdetection/data/foggy_cityscapes_median'
out_dir = osp.join(cityscapes_path, 'annotaions')
mmcv.mkdir_or_exist(out_dir)
img_dir = osp.join(cityscapes_path, args.img_dir)
gt_dir = osp.join(cityscapes_path, args.gt_dir)
set_name = dict(train='instancesonly_filtered_gtFine_train.json',
val='instancesonly_filtered_gtFine_val.json')
for split, json_name in set_name.items():
print(f'Converting {split} into {json_name}')
with mmcv.Timer(
print_tmpl='It tooks {}s to convert Cityscapes annotation'
):
files = collect_files(osp.join(img_dir, split),
osp.join(gt_dir, split), beta)
image_infos = collect_annotations(files, nproc=args.nproc)
cvt_annotations(image_infos, osp.join(out_dir, json_name))
def main():
args = parse_args()
root_path = args.root_path
with mmcv.Timer(print_tmpl='It takes {}s to convert BID annotation'):
files = collect_files(
osp.join(root_path, 'imgs'), osp.join(root_path, 'annotations'))
image_infos = collect_annotations(files, nproc=args.nproc)
generate_ann(root_path, image_infos, args.preserve_vertical,
args.val_ratio, args.format)
def main():
args = parse_args()
root_path = args.root_path
for split in ['train', 'val', 'test']:
print(f'Processing {split} set...')
with mmcv.Timer(print_tmpl='It takes {}s to convert IMGUR annotation'):
anno_infos = collect_imgur_info(
root_path, f'imgur5k_annotations_{split}.json')
generate_ann(root_path, split, anno_infos, args.format)
def main():
args = parse_args()
root_path = args.root_path
for split in ['training', 'test']:
print(f'Processing {split} set...')
with mmcv.Timer(print_tmpl='It takes {}s to convert FUNSD annotation'):
files = collect_files(osp.join(root_path, 'imgs'),
osp.join(root_path, 'annotations', split))
image_infos = collect_annotations(files, nproc=args.nproc)
generate_ann(root_path, split, image_infos, args.preserve_vertical,
args.format)
def main():
args = parse_args()
root_path = args.root_path
for split in ['train', 'val', 'test']:
print(f'Processing {split} set...')
with mmcv.Timer(print_tmpl='It takes {}s to convert LV annotation'):
files = collect_files(osp.join(root_path, 'imgs', split))
image_infos = collect_annotations(files, nproc=args.nproc)
convert_annotations(
image_infos, osp.join(root_path,
'instances_' + split + '.json'))
def main():
args = parse_args()
root_path = args.root_path
ratio = args.val_ratio
trn_files, val_files = collect_files(
osp.join(root_path, 'imgs'), osp.join(root_path, 'annotations'), ratio)
# Train set
trn_infos = collect_annotations(trn_files, nproc=args.nproc)
with mmcv.Timer(
print_tmpl='It takes {}s to convert KAIST Training annotation'):
convert_annotations(trn_infos,
osp.join(root_path, 'instances_training.json'))
# Val set
if len(val_files) > 0:
val_infos = collect_annotations(val_files, nproc=args.nproc)
with mmcv.Timer(
print_tmpl='It takes {}s to convert KAIST Val annotation'):
convert_annotations(val_infos,
osp.join(root_path, 'instances_val.json'))
def main():
args = parse_args()
root_path = args.root_path
ratio = args.val_ratio
trn_files, val_files = collect_files(osp.join(root_path, 'imgs'),
osp.join(root_path, 'annotations'),
ratio)
# Train set
trn_infos = collect_annotations(trn_files, nproc=args.nproc)
with mmcv.Timer(
print_tmpl='It takes {}s to convert MTWI Training annotation'):
generate_ann(root_path, 'training', trn_infos, args.preserve_vertical,
args.format)
# Val set
if len(val_files) > 0:
val_infos = collect_annotations(val_files, nproc=args.nproc)
with mmcv.Timer(
print_tmpl='It takes {}s to convert MTWI Val annotation'):
generate_ann(root_path, 'val', val_infos, args.preserve_vertical,
args.format)
def main():
args = parse_args()
root_path = args.root_path
split_info = mmcv.load(
osp.join(root_path, 'annotations', 'train_valid_test_split.json'))
split_info['training'] = split_info.pop('train')
split_info['val'] = split_info.pop('valid')
for split in ['training', 'val', 'test']:
print(f'Processing {split} set...')
with mmcv.Timer(print_tmpl='It takes {}s to convert NAF annotation'):
files = collect_files(osp.join(root_path, 'imgs'),
osp.join(root_path, 'annotations'),
split_info[split])
image_infos = collect_annotations(files, nproc=args.nproc)
generate_ann(root_path, split, image_infos, args.preserve_vertical,
args.format)
def main():
args = parse_args()
root_path = args.root_path
with mmcv.Timer(print_tmpl='It takes {}s to convert BID annotation'):
files = collect_files(osp.join(root_path, 'imgs'),
osp.join(root_path, 'annotations'))
image_infos = collect_annotations(files, nproc=args.nproc)
if args.val_ratio:
image_infos = split_train_val_list(image_infos, args.val_ratio)
splits = ['training', 'val']
else:
image_infos = [image_infos]
splits = ['training']
for i, split in enumerate(splits):
convert_annotations(
image_infos[i],
osp.join(root_path, 'instances_' + split + '.json'))
def _f(*args, **kwargs):
import mmcv
timer = mmcv.Timer()
import inspect
from .utils import identify
ident_name = identify((inspect.getsource(func), args, kwargs))
if not ident_name in ICACHE:
# logger.warning('{} not in CACHE: "{}"'.format(ident_name, ICACHE))
result = func(*args, **kwargs)
logger.info('Imemoize {}, init: runtime: {:0.2f} s'.format(
func.__name__, timer.since_last_check()))
ICACHE[ident_name] = result
else:
result = ICACHE[ident_name]
logger.info('Imemoize {} reuse, runtime: {:0.2f} s'.format(
func.__name__, timer.since_last_check()))
return result
def main():
args = parse_args()
root_path = args.root_path
img_dir = osp.join(root_path, 'imgs')
gt_dir = osp.join(root_path, 'annotations')
set_name = {}
for split in ['training', 'test']:
set_name.update({split: split + '_label' + '.txt'})
assert osp.exists(osp.join(img_dir, split))
for split, ann_name in set_name.items():
print(f'Converting {split} into {ann_name}')
with mmcv.Timer(
print_tmpl='It takes {}s to convert totaltext annotation'):
files = collect_files(osp.join(img_dir, split),
osp.join(gt_dir, split))
image_infos = collect_annotations(files, nproc=args.nproc)
generate_ann(root_path, split, image_infos)
def main():
args = parse_args()
work_path = args.work_path
out_dir = args.out_dir if args.out_dir else work_path
mmcv.mkdir_or_exist(out_dir)
set_name = dict(
train='instancesonly_filtered_train.json',
val='instancesonly_filtered_val.json',
# test='instancesonly_filtered_test.json'
)
for split, json_name in set_name.items():
print(f'Converting {split} into {json_name}')
with mmcv.Timer(print_tmpl='It tooks {}s to convert coco annotation'):
out_json = img2coco(osp.join(work_path, split))
# with open('json_name'.format(ROOT_DIR), 'w') as output_json_file:
# json.dump(coco_output, output_json_file)
mmcv.dump(out_json, osp.join(out_dir, json_name))
def main():
args = parse_args()
cityscapes_path = args.cityscapes_path
out_dir = args.out_dir if args.out_dir else cityscapes_path
mmcv.mkdir_or_exist(out_dir)
img_dir = osp.join(cityscapes_path, args.img_dir)
gt_dir = osp.join(cityscapes_path, args.gt_dir)
set_name = dict(train='instancesonly_filtered_gtFine_train.json',
val='instancesonly_filtered_gtFine_val.json',
test='instancesonly_filtered_gtFine_test.json')
for split, json_name in set_name.items():
print(f'Converting {split} into {json_name}')
with mmcv.Timer(
print_tmpl='It took {}s to convert Cityscapes annotation'):
files = collect_files(osp.join(img_dir, split),
osp.join(gt_dir, split))
image_infos = collect_annotations(files, nproc=args.nproc)
cvt_annotations(image_infos, osp.join(out_dir, json_name))
def main():
args = parse_args()
root_path = args.root_path
out_dir = args.out_dir if args.out_dir else root_path
mmcv.mkdir_or_exist(out_dir)
img_dir = osp.join(root_path, 'imgs')
gt_dir = osp.join(root_path, 'annotations')
set_name = {}
for split in args.split_list:
set_name.update({split: 'instances_' + split + '.json'})
assert osp.exists(osp.join(img_dir, split))
for split, json_name in set_name.items():
print(f'Converting {split} into {json_name}')
with mmcv.Timer(print_tmpl='It takes {}s to convert icdar annotation'):
files = collect_files(osp.join(img_dir, split),
osp.join(gt_dir, split), split)
image_infos = collect_annotations(files, split, nproc=args.nproc)
convert_annotations(image_infos, osp.join(out_dir, json_name))
def main(args):
train_loader = get_loader(args)
n_data = len(train_loader.dataset)
logger.info("length of training dataset: {}".format(n_data))
model, model_ema = build_model(args)
logger.info('{}'.format(model))
contrast = MemorySeCo(128, args.nce_k, args.nce_t, args.nce_t_intra).cuda()
criterion = NCESoftmaxLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
lr=args.batch_size * dist.get_world_size() /
256 * args.base_lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
scheduler = get_scheduler(optimizer, len(train_loader), args)
model = DistributedDataParallel(model,
device_ids=[args.local_rank],
broadcast_buffers=args.broadcast_buffer)
logger.info('Distributed Enabled')
# optionally resume from a checkpoint
if args.resume:
assert os.path.isfile(args.resume)
load_checkpoint(args, model, model_ema, contrast, optimizer, scheduler,
logger.info)
# routine
logger.info('Training')
timer = mmcv.Timer()
for epoch in range(args.start_epoch, args.epochs + 1):
train_loader.sampler.set_epoch(epoch)
loss = train_seco(epoch, train_loader, model, model_ema, contrast,
criterion, optimizer, scheduler, args)
logger.info('epoch {}, total time {:.2f}, loss={}'.format(
epoch, timer.since_last_check(), loss))
if dist.get_rank() == 0:
save_checkpoint(args, epoch, model, model_ema, contrast, optimizer,
scheduler, logger.info)
dist.barrier()
print(task)
# for i, task in enumerate(mmcv.track_iter_progress(tasks)):
# do something like print
# print(i)
# print(task)
if flag_3:
# 计时
"""
It is convinient to compute the runtime of a code block with Timer.
"""
import time
import mmcv
with mmcv.Timer():
# simulate some code block
# time.sleep(1)
for _ in range(1000):
a = 1
b = 2
c = a + b
d = c ^ 9
e = int(d / 888)
"""
or try with since_start() and since_last_check().
This former can return the runtime since the timer starts and the latter will return the time since the last time checked.
"""
timer = mmcv.Timer()
# code block 1 here
time.sleep(2)
def after_step(self, current_step):
# import ipdb; ipdb.set_trace()
if current_step % self.trainer.config.TRAIN.eval_step == 0 and current_step!= 0:
self.trainer.logger.info('Start clsuter the feature')
frame_num = self.trainer.config.DATASET.train_clip_length
frame_step = self.trainer.config.DATASET.train_clip_step
feature_record = []
for video_name in self.trainer.cluster_dataset_keys:
dataset = self.trainer.cluster_dataset_dict[video_name]
data_loader = DataLoader(dataset=dataset, batch_size=1, shuffle=False, num_workers=1)
# import ipdb; ipdb.set_trace()
for data in data_loader:
future = data[:, 2, :, :, :].cuda() # t+1 frame
current = data[:, 1, :, :, :].cuda() # t frame
past = data[:, 0, :, :, :].cuda() # t frame
bboxs = self.trainer.get_batch_dets(current)
for index, bbox in enumerate(bboxs):
# import ipdb; ipdb.set_trace()
if bbox.numel() == 0:
# import ipdb; ipdb.set_trace()
# bbox = torch.zeros([1,4])
bbox = bbox.new_zeros([1,4])
# print('NO objects')
# continue
# import ipdb; ipdb.set_trace()
current_object, _ = multi_obj_grid_crop(current[index], bbox)
future_object, _ = multi_obj_grid_crop(future[index], bbox)
future2current = torch.stack([future_object, current_object], dim=1)
past_object, _ = multi_obj_grid_crop(past[index], bbox)
current2past = torch.stack([current_object, past_object], dim=1)
_, _, A_input = frame_gradient(future2current)
A_input = A_input.sum(1)
_, _, C_input = frame_gradient(current2past)
C_input = C_input.sum(1)
A_feature, _ = self.trainer.A(A_input)
B_feature, _ = self.trainer.B(current_object)
C_feature, _ = self.trainer.C(C_input)
A_flatten_feature = A_feature.flatten(start_dim=1)
B_flatten_feature = B_feature.flatten(start_dim=1)
C_flatten_feature = C_feature.flatten(start_dim=1)
ABC_feature = torch.cat([A_flatten_feature, B_flatten_feature, C_flatten_feature], dim=1).detach()
# import ipdb; ipdb.set_trace()
ABC_feature_s = torch.chunk(ABC_feature, ABC_feature.size(0), dim=0)
# feature_record.extend(ABC_feature_s)
for abc_f in ABC_feature_s:
temp = abc_f.squeeze(0).cpu().numpy()
feature_record.append(temp)
# import ipdb; ipdb.set_trace()
self.trainer.logger.info(f'Finish the video:{video_name}')
self.trainer.logger.info(f'Finish extract feature, the sample:{len(feature_record)}')
# model = KMeans(n_clusters=self.trainer.config.TRAIN.cluster.k)
device = torch.device('cuda:0')
cluster_input = torch.from_numpy(np.array(feature_record))
time = mmcv.Timer()
# import ipdb; ipdb.set_trace()
cluster_centers = cluster_input.new_zeros(size=[self.trainer.config.TRAIN.cluster.k, 3072])
for _ in range(10):
cluster_ids_x, cluster_center = kmeans(X=cluster_input, num_clusters=self.trainer.config.TRAIN.cluster.k, distance='euclidean', device=device)
cluster_centers += cluster_center
import ipdb; ipdb.set_trace()
cluster_centers = cluster_centers / 10
# model.fit(cluster_input)
# pusedo_labels = model.predict(cluster_input)
pusedo_labels = kmeans_predict(cluster_input, cluster_centers, 'euclidean', device=device).detach().cpu().numpy()
print(f'The cluster time is :{time.since_start()/10} min')
# import ipdb; ipdb.set_trace()
# pusedo_labels = np.split(pusedo_labels, pusedo_labels.shape[0], 0)
pusedo_dataset = os.path.join(self.trainer.config.TRAIN.pusedo_data_path, 'pusedo')
if not os.path.exists(pusedo_dataset):
os.mkdir(pusedo_dataset)
np.savez_compressed(os.path.join(pusedo_dataset, f'{self.trainer.config.DATASET.name}_dummy.npz'), data=cluster_input, label=pusedo_labels)
print(f'The save time is {time.since_last_check() / 60} min')
# binary_labels = MultiLabelBinarizer().fit_transform(pusedo_labels)
# self.trainer.ovr_model = OneVsRestClassifier(LinearSVC(random_state = 0)).fit(cluster_input,binary_labels)
self.trainer.ovr_model = OneVsRestClassifier(LinearSVC(random_state = 0), n_jobs=16).fit(cluster_input, pusedo_labels)
print(f'The train ovr: {time.since_last_check() / 60} min')
print(test)
print('Gradcheck for carafe naive...')
test = gradcheck(CARAFENaive(5, 4, 2), (feat, mask), atol=1e-4, eps=1e-4)
print(test)
feat = torch.randn(2, 1024, 100, 100, requires_grad=True,
device='cuda:0').float()
mask = torch.randn(2, 25, 200, 200, requires_grad=True,
device='cuda:0').sigmoid().float()
loop_num = 500
time_forward = 0
time_backward = 0
bar = mmcv.ProgressBar(loop_num)
timer = mmcv.Timer()
for i in range(loop_num):
x = carafe(feat.clone(), mask.clone(), 5, 1, 2)
torch.cuda.synchronize()
time_forward += timer.since_last_check()
x.sum().backward(retain_graph=True)
torch.cuda.synchronize()
time_backward += timer.since_last_check()
bar.update()
print('\nCARAFE time forward: {} ms/iter | time backward: {} ms/iter'.format(
(time_forward + 1e-3) * 1e3 / loop_num,
(time_backward + 1e-3) * 1e3 / loop_num))
time_naive_forward = 0
time_naive_backward = 0
bar = mmcv.ProgressBar(loop_num)
def train_seco(epoch, train_loader, model, model_ema, contrast, criterion,
optimizer, scheduler, args):
model.train()
set_bn_train(model_ema)
batch_time = AverageMeter()
loss_meter = AverageMeter()
timer = mmcv.Timer()
for idx, (xq, x1, x2, x3, binary_order) in enumerate(train_loader):
xq = xq.cuda(non_blocking=True) # query
x1 = x1.cuda(non_blocking=True) # same frame diff aug
x2 = x2.cuda(non_blocking=True) # diff frame 1
x3 = x3.cuda(non_blocking=True) # diff frame 2
binary_order = binary_order.cuda(non_blocking=True)
# forward keys
with torch.no_grad():
x1_shuffled, x1_backward_inds = DistributedShuffle.forward_shuffle(
x1)
x2_shuffled, x2_backward_inds = DistributedShuffle.forward_shuffle(
x2)
x3_shuffled, x3_backward_inds = DistributedShuffle.forward_shuffle(
x3)
x1_feat_inter, x1_feat_intra, x1_feat_order = model_ema(
x1_shuffled)
x2_feat_inter, x2_feat_intra, x2_feat_order = model_ema(
x2_shuffled)
x3_feat_inter, x3_feat_intra, x3_feat_order = model_ema(
x3_shuffled)
x1_feat_inter_all, x1_feat_inter = DistributedShuffle.backward_shuffle(
x1_feat_inter, x1_backward_inds)
x1_feat_intra_all, x1_feat_intra = DistributedShuffle.backward_shuffle(
x1_feat_intra, x1_backward_inds)
x2_feat_inter_all, x2_feat_inter = DistributedShuffle.backward_shuffle(
x2_feat_inter, x2_backward_inds)
x2_feat_intra_all, x2_feat_intra = DistributedShuffle.backward_shuffle(
x2_feat_intra, x2_backward_inds)
x2_feat_order_all, x2_feat_order = DistributedShuffle.backward_shuffle(
x2_feat_order, x2_backward_inds)
x3_feat_inter_all, x3_feat_inter = DistributedShuffle.backward_shuffle(
x3_feat_inter, x3_backward_inds)
x3_feat_intra_all, x3_feat_intra = DistributedShuffle.backward_shuffle(
x3_feat_intra, x3_backward_inds)
x3_feat_order_all, x3_feat_order = DistributedShuffle.backward_shuffle(
x3_feat_order, x3_backward_inds)
# forward query
xq_feat_inter, xq_feat_intra, xq_feat_order, xq_logit_order = model(
xq,
order_feat=torch.cat(
[x2_feat_order.detach(),
x3_feat_order.detach()], dim=1))
out_inter = contrast(
xq_feat_inter,
x1_feat_inter,
x2_feat_inter,
x3_feat_inter,
torch.cat(
[x1_feat_inter_all, x2_feat_inter_all, x3_feat_inter_all],
dim=0),
inter=True)
# loss calc
out_intra = contrast(xq_feat_intra,
x1_feat_intra,
x2_feat_intra,
x3_feat_intra,
None,
inter=False)
loss_inter = criterion(out_inter)
loss_intra = criterion(out_intra)
loss_order = torch.nn.functional.cross_entropy(xq_logit_order,
binary_order)
loss = loss_inter + loss_intra + loss_order
# backward
optimizer.zero_grad()
loss.backward()
# update params
optimizer.step()
scheduler.step()
moment_update(model, model_ema, args.alpha)
# update meters
loss_meter.update(loss.item())
batch_time.update(timer.since_last_check())
# print info
if idx % args.print_freq == 0:
logger.info(
'Train: [{:>3d}]/[{:>4d}/{:>4d}] BT={:>0.3f}/{:>0.3f} Loss={:>0.3f} {:>0.3f} {:>0.3f} {:>0.3f}/{:>0.3f}'
.format(
epoch,
idx,
len(train_loader),
batch_time.val,
batch_time.avg,
loss.item(),
loss_inter.item(),
loss_intra.item(),
loss_order.item(),
loss_meter.avg,
))
return loss_meter.avg
