def validate_epoch(epoch, trainer, val_dataloader, meters): end = time.time() with tqdm_pbar(total=len(val_dataloader)) as pbar: for feed_dict in val_dataloader: if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end; end = time.time() output_dict, extra_info = trainer.evaluate(feed_dict) # TODO(Jiayuan Mao @ 04/26): compute the monitoring values. monitors = as_float(output_dict['monitors']) step_time = time.time() - end; end = time.time() # TODO(Jiayuan Mao @ 04/23): normalize the loss/other metrics by adding n=xxx if applicable. meters.update(monitors) meters.update({'time/data': data_time, 'time/step': step_time}) if args.use_tb: meters.flush() pbar.set_description(meters.format_simple( 'Epoch {} (validation)'.format(epoch), {k: v for k, v in meters.val.items() if k.startswith('validation') and k.count('/') <= 2}, compressed=True ), refresh=False) pbar.update() end = time.time()
def validate_epoch(model, val_dataloader, meters): end = time.time() with tqdm_pbar(total=len(val_dataloader)) as pbar: for feed_dict in val_dataloader: if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end end = time.time() output_dict = model(feed_dict) # TODO(Jiayuan Mao @ 04/26): compute the monitoring values. monitors = as_float(output['monitors']) step_time = time.time() - end end = time.time() # TODO(Jiayuan Mao @ 04/23): normalize the loss/other metrics by adding n=xxx if applicable. meters.update(monitors) meters.update({'time/data': data_time, 'time/step': step_time}) if args.use_tb: meters.flush() pbar.set_description( meters.format_simple('Test', 'val', compressed=True)) pbar.update() end = time.time()
def validate_epoch(epoch, trainer, val_dataloader, meters, meter_prefix='validation'): end = time.time() with tqdm_pbar(total=len(val_dataloader)) as pbar: for feed_dict in val_dataloader: if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end; end = time.time() output_dict, extra_info = trainer.evaluate(feed_dict, cast_tensor=False) monitors = {meter_prefix + '/' + k: v for k, v in as_float(output_dict['monitors']).items()} step_time = time.time() - end; end = time.time() n = feed_dict['image'].size(0) meters.update(monitors, n=n) meters.update({'time/data': data_time, 'time/step': step_time}) if args.use_tb: meters.flush() pbar.set_description(meters.format_simple( 'Epoch {} (validation)'.format(epoch), {k: v for k, v in meters.val.items() if k.startswith('validation') and k.count('/') <= 2}, compressed=True )) pbar.update() end = time.time()
def _mining_epoch(self, mining_epoch_size, mining_dataset_size): """Take exam, collect and update positive dataset and negative dataset""" pos_data = RandomlyIterDataset() neg_data = RandomlyIterDataset() self.model.eval() meters = GroupMeters() with tqdm_pbar(total=mining_epoch_size) as pbar: for i in range(mining_epoch_size): message, result = self._get_result(i, meters, mode='mining') positive, number, backup = self._extract_info(result) dataset = pos_data if positive else neg_data if dataset.size < mining_dataset_size: dataset.append((number, backup)) pbar.set_description(message) pbar.update() # When both positive and negative dataset are full, break. if pos_data.size >= mining_dataset_size and \ neg_data.size >= mining_dataset_size: break logger.info(meters.format_simple('> Mining: ', compressed=False)) self._inherit_neg_data(neg_data, self.neg_data, meters, mining_dataset_size) self.pos_data = pos_data self.neg_data = neg_data self._dump_meters(meters, 'mining') return meters
def map(self, func, iterable, chunksize=1, sort=True, total=None, desc='', callback=None, use_tqdm=True, update_interval=0.1, update_iters=1, **kwargs): if total is None and isinstance(iterable, collections.Sized): total = len(iterable) if use_tqdm: pbar = tqdm_pbar(total=total, **kwargs) with pbar: return super().map(func, iterable, chunksize, sort, callback=self._wrap_callback( callback, pbar, desc, update_interval=update_interval, update_iters=update_iters)) else: return super().map(func, iterable, chunksize, sort, callback=callback)
def tqdm_for(total, func): """wrapper of the for function with message showing on the progress bar.""" # Not support break cases for now. with tqdm_pbar(total=total) as pbar: for i in range(total): message = func(i) pbar.set_description(message) pbar.update()
def tqdm_for(total, func): """wrapper of the for function with message showing on the progress bar.""" # Not support break cases for now. disable = False if os.getenv("ONCLUSTER") is not None: disable = True with tqdm_pbar(total=total, disable=disable) as pbar: for i in range(total): message = func(i) pbar.set_description(message) pbar.update()
def main(): logger.critical('Loading the word embedding.') vocab, word_embeddings = load_word_embedding(args.vse) logger.critical('Building up the model.') model = CompletionModel(word_embeddings) if args.use_gpu: model.cuda() # Disable the cudnn benchmark. model.eval() cudnn.benchmark = False logger.critical('Loading the dataset.') dev_dataset = CompletionDataset(vocab, pjoin(args.data_dir, args.dev_img), pjoin(args.data_dir, args.dev_cap), mode=args.mode) test_dataset = CompletionDataset(vocab, pjoin(args.data_dir, args.test_img), pjoin(args.data_dir, args.test_cap), mode=args.mode) logger.critical('Building up the data loader.') dev_dataloader = make_dataloader(dev_dataset, num_workers=args.data_workers, batch_size=64, shuffle=False, drop_last=False, pin_memory=True) test_dataloader = make_dataloader(test_dataset, num_workers=args.data_workers, batch_size=64, shuffle=False, drop_last=False, pin_memory=True) for epoch_id in range(1, 11): load_weights(model, pjoin(args.load, 'epoch_{}.pth'.format(epoch_id))) for loader in [dev_dataloader, test_dataloader]: meters = GroupMeters() end = time.time() with tqdm_pbar(total=len(loader), leave=False) as pbar: for i, data in enumerate(loader): feed_dict = data feed_dict = mark_volatile(feed_dict) if args.use_gpu: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end; end = time.time() output_dict = model(feed_dict) output_dict = as_numpy(output_dict) gpu_time = time.time() - end; end = time.time() meters.update({k: float(v) for k, v in output_dict.items() if k.startswith('top')}, n=len(feed_dict['image'])) meters.update({'time/data': data_time, 'time/gpu': gpu_time}) pbar.set_description(format_meters('sentid={}'.format(i), meters.val, '{}={:.4f}', ', ')) pbar.update() end = time.time() print(epoch_id, sorted(meters.avg.items()))
def train_epoch(epoch, trainer, train_dataloader, meters): nr_iters = args.iters_per_epoch if nr_iters == 0: nr_iters = len(train_dataloader) meters.update(epoch=epoch) trainer.trigger_event("epoch:before", trainer, epoch) train_iter = iter(train_dataloader) end = time.time() with tqdm_pbar(total=nr_iters) as pbar: for i in range(nr_iters): feed_dict = next(train_iter) if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end end = time.time() loss, monitors, output_dict, extra_info = trainer.step( feed_dict, cast_tensor=False) step_time = time.time() - end end = time.time() n = feed_dict["image"].size(0) meters.update(loss=loss, n=n) meters.update(monitors, n=n) meters.update({"time/data": data_time, "time/step": step_time}) if args.use_tb: meters.flush() pbar.set_description( meters.format_simple( "Epoch {}".format(epoch), { k: v for k, v in meters.val.items() if not k.startswith("validation") and k != "epoch" and k.count("/") <= 1 }, compressed=True, )) pbar.update() end = time.time() trainer.trigger_event("epoch:after", trainer, epoch)
def train_epoch(epoch, trainer, train_dataloader, meters): nr_iters = args.iters_per_epoch if nr_iters == 0: nr_iters = len(train_dataloader) meters.update(epoch=epoch) if args.dataset=='blocks' and epoch==6: keep_only_temporal_concept_learner(trainer, args, configs) trainer.trigger_event('epoch:before', trainer, epoch) train_iter = iter(train_dataloader) end = time.time() with tqdm_pbar(total=nr_iters) as pbar: for i in range(nr_iters): feed_dict = next(train_iter) if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end; end = time.time() loss, monitors, output_dict, extra_info = trainer.step(feed_dict, cast_tensor=False) step_time = time.time() - end; end = time.time() n = len(feed_dict) meters.update(loss=loss, n=n) for tmp_key, tmp_value in monitors.items(): if isinstance(tmp_value , list): for sub_idx, sub_value in enumerate(tmp_value): if sub_value[0]==-1: continue meters.update({tmp_key: sub_value[0]}, n=sub_value[1]) elif tmp_value==-1: continue else: meters.update({tmp_key: tmp_value}, n=1) meters.update({'time/data': data_time, 'time/step': step_time}) if args.use_tb: meters.flush() pbar.set_description(meters.format_simple( 'Epoch {}'.format(epoch), {k: v for k, v in meters.val.items() if not k.startswith('validation') and k != 'epoch' and k.count('/') <= 1}, compressed=True )) pbar.update() end = time.time() trainer.trigger_event('epoch:after', trainer, epoch)
def train_epoch(epoch, trainer, train_dataloader, meters): nr_iters = args.iters_per_epoch if nr_iters == 0: nr_iters = len(train_dataloader) meters.update(epoch=epoch) trainer.trigger_event('epoch:before', trainer, epoch) train_iter = iter(train_dataloader) end = time.time() with tqdm_pbar(total=nr_iters) as pbar: for i in range(nr_iters): feed_dict = next(train_iter) if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end end = time.time() loss, monitors, output_dict, extra_info = trainer.step(feed_dict) step_time = time.time() - end end = time.time() # TODO(Jiayuan Mao @ 04/23): normalize the loss/monitors by adding n=xxx if applicable. meters.update(loss=loss) meters.update(monitors) meters.update({'time/data': data_time, 'time/step': step_time}) if args.use_tb: meters.flush() # TODO(Jiayuan Mao @ 04/23): customize the logger. pbar.set_description(meters.format_simple( 'Epoch {}'.format(epoch), { k: v for k, v in meters.val.items() if not k.startswith('validation') and k.count('/') <= 1 }, compressed=True), refresh=False) pbar.update() end = time.time() trainer.trigger_event('epoch:after', trainer, epoch)
def download(url, dirname, cli=True, filename=None, md5=None): """ Download URL to a directory. Will figure out the filename automatically from URL. Will figure out the filename automatically from URL, if not given.""" # From: https://github.com/ppwwyyxx/tensorpack/blob/master/tensorpack/utils/fs.py if cli: from jacinle.cli.keyboard import maybe_mkdir maybe_mkdir(dirname) else: assert osp.isdir(dirname) filename = filename or url.split('/')[-1] path = os.path.join(dirname, filename) def hook(t): last_b = [0] def inner(b, bsize, tsize=None): if tsize is not None: t.total = tsize t.update((b - last_b[0]) * bsize) last_b[0] = b return inner try: with tqdm_pbar(unit='B', unit_scale=True, miniters=1, desc=filename) as pbar: path, _ = urllib.request.urlretrieve(url, path, reporthook=hook(pbar)) statinfo = os.stat(path) size = statinfo.st_size except Exception: print('Failed to download {}.'.format(url)) raise assert size > 0, "Download an empty file!" print('Successfully downloaded ' + filename + " " + fsize_format(size) + '.') if md5 is not None: assert check_integrity( path, md5), 'Integrity check for {} failed'.format(path) return path
def validate_epoch(epoch, trainer, val_dataloader, meters, meter_prefix='validation'): if args.testing_flag: json_output_list = [] end = time.time() with tqdm_pbar(total=len(val_dataloader)*args.batch_size) as pbar: for feed_dict in val_dataloader: if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) #pdb.set_trace() data_time = time.time() - end; end = time.time() output_dict_list, extra_info = trainer.evaluate(feed_dict, cast_tensor=False) if args.testing_flag: prepare_data_for_testing(output_dict_list, feed_dict, json_output_list) step_time = time.time() - end; end = time.time() for idx, mon_dict in enumerate(output_dict_list['monitors']): monitors = {meter_prefix + '/' + k: v for k, v in as_float(mon_dict).items()} # remove padding values for tmp_key, tmp_value in monitors.items(): if isinstance(tmp_value , list): for sub_idx, sub_value in enumerate(tmp_value): if sub_value[0]==-1: continue meters.update({tmp_key: sub_value[0]}, n=sub_value[1]) elif tmp_value==-1: continue else: meters.update({tmp_key: tmp_value}, n=1) meters.update({'time/data': data_time, 'time/step': step_time}) if args.use_tb: meters.flush() pbar.set_description(meters.format_simple( 'Epoch {} (validation)'.format(epoch), {k: v for k, v in meters.val.items() if k.startswith('validation') and k.count('/') <= 2}, compressed=True )) pbar.update() end = time.time() if args.testing_flag==1: jsondump(args.test_result_path, json_output_list)
def validate_epoch(epoch, trainer, val_dataloader, meters, meter_prefix="validation"): end = time.time() with tqdm_pbar(total=len(val_dataloader)) as pbar: for feed_dict in val_dataloader: if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end end = time.time() output_dict, extra_info = trainer.evaluate(feed_dict, cast_tensor=False) monitors = { meter_prefix + "/" + k: v for k, v in as_float(output_dict["monitors"]).items() } step_time = time.time() - end end = time.time() n = feed_dict["image"].size(0) meters.update(monitors, n=n) meters.update({"time/data": data_time, "time/step": step_time}) if args.use_tb: meters.flush() pbar.set_description( meters.format_simple( "Epoch {} (validation)".format(epoch), { k: v for k, v in meters.val.items() if (k.startswith(meter_prefix)) and k.count("/") <= 2 }, compressed=True, )) pbar.update() end = time.time()
def _mining_epoch(self, mining_epoch_size, mining_dataset_size): """Take exam, collect and update positive dataset and negative dataset""" pos_data = RandomlyIterDataset() neg_data = RandomlyIterDataset() self.model.eval() meters_deter = GroupMeters() meters_stoch = GroupMeters() disable_pbar = False if os.getenv("ONCLUSTER") is not None: disable_pbar = True with tqdm_pbar(total=mining_epoch_size, disable=disable_pbar) as pbar: for i in range(mining_epoch_size): if i % 2 == 0: message, result = self._get_result(i, meters_deter, mode='mining-deter') else: message, result = self._get_result(i, meters_stoch, mode='mining-stoch') positive, number, backup = self._extract_info(result) dataset = pos_data if positive else neg_data if dataset.size < mining_dataset_size: dataset.append((number, backup)) pbar.set_description(message) pbar.update() # When both positive and negative dataset are full, break. if pos_data.size >= mining_dataset_size and \ neg_data.size >= mining_dataset_size: break logger.info( meters_deter.format_simple('> Mining (deter): ', compressed=False)) logger.info( meters_stoch.format_simple('> Mining (stoch): ', compressed=False)) meters = self.best_meters(meters_deter, meters_stoch) self._inherit_neg_data(neg_data, self.neg_data, meters, mining_dataset_size) self.pos_data = pos_data self.neg_data = neg_data self._dump_meters(meters_deter, 'mining-deter') self._dump_meters(meters_stoch, 'mining-stoch') return meters, meters_deter, meters_stoch
def map(self, func, iterable, chunksize=1, sort=True, total=None, desc='', callback=None, use_tqdm=True, **kwargs): if total is None and isinstance(iterable, collections.Sized): total = len(iterable) if use_tqdm: pbar = tqdm_pbar(total=total, **kwargs) super().map(func, iterable, chunksize, sort, callback=self._wrap_callback(callback, pbar, desc)) else: super().map(func, iterable, chunksize, sort, callback=callback)
def train_epoch(epoch, train_loader, trainer, meters): nr_iters = args.iters_per_epoch if nr_iters == 0: nr_iters = len(train_loader) meters.reset() end = time.time() trainer.trigger_event('epoch:before', trainer, epoch) train_iter = iter(train_loader) with tqdm_pbar(total=nr_iters) as pbar: for i in range(nr_iters): feed_dict = next(train_iter) if not args.gpu_parallel and args.use_gpu: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end; end = time.time() loss, monitors, output_dict, extra_info = trainer.step(feed_dict) step_time = time.time() - end; end = time.time() meters.update(loss=loss) meters.update(monitors) meters.update({'time/data': data_time, 'time/step': step_time}) if args.use_tb: meters.flush() pbar.set_description(format_meters('iter={}/{}'.format(epoch, i), {k: v for k, v in meters.val.items() if k.startswith('loss') or k.startswith('time')}, '{}={:.4f}', ', ')) pbar.update() end = time.time() trainer.trigger_event('epoch:after', trainer, epoch)
def validate_epoch(epoch, model, val_dataloader, meters, meter_prefix='validation'): end = time.time() visualized = 0 vis = HTMLTableVisualizer(args.vis_dir, 'NSCL Execution Visualization') vis.begin_html() try: with tqdm_pbar(total=len(val_dataloader)) as pbar: for feed_dict in val_dataloader: if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) data_time = time.time() - end end = time.time() output_dict = model(feed_dict) monitors = { meter_prefix + '/' + k: v for k, v in as_float(output_dict['monitors']).items() } step_time = time.time() - end end = time.time() n = feed_dict['image'].size(0) meters.update(monitors, n=n) meters.update({'time/data': data_time, 'time/step': step_time}) feed_dict = GView(as_detached(as_cpu(feed_dict))) output_dict = GView(as_detached(as_cpu(output_dict))) for i in range(n): with vis.table( 'Visualize #{} Metainfo'.format(visualized), [ HTMLTableColumnDesc('id', 'QID', 'text', {'width': '50px'}), HTMLTableColumnDesc('image', 'Image', 'figure', {'width': '400px'}), HTMLTableColumnDesc('qa', 'QA', 'text', {'width': '200px'}), HTMLTableColumnDesc('p', 'Program', 'code', {'width': '200px'}) ]): image_filename = osp.join(args.data_image_root, feed_dict.image_filename[i]) image = Image.open(image_filename) fig, ax = vis_bboxes(image, feed_dict.objects_raw[i], 'object', add_text=False) _ = ax.set_title('object bounding box annotations') QA_string = """ <p><b>Q</b>: {}</p> <p><b>A</b>: {}</p> """.format(feed_dict.question_raw[i], feed_dict.answer[i]) P_string = '\n'.join( [repr(x) for x in feed_dict.program_seq[i]]) vis.row(id=i, image=fig, qa=QA_string, p=P_string) plt.close() with vis.table( 'Visualize #{} Metainfo'.format(visualized), [ HTMLTableColumnDesc('id', 'QID', 'text', {'width': '50px'}), HTMLTableColumnDesc('image', 'Image', 'figure', {'width': '400px'}), HTMLTableColumnDesc('mask', 'Mask', 'figure', {'width': '700px'}) ]): image_filename = osp.join(args.data_image_root, feed_dict.image_filename[i]) image = Image.open(image_filename) fig, ax = vis_bboxes(image, feed_dict.objects_raw[i], 'object', add_text=False) _ = ax.set_title('object bounding box annotations') if not args.show_mask: montage = fig else: num_slots = output_dict['monet/m'].shape[1] monet_fig = [ [ tensor2im(output_dict['monet/m'][i, k]) for k in range(num_slots) ], [ tensor2im(output_dict['monet/x'][i, k]) for k in range(num_slots) ], [ tensor2im(output_dict['monet/xm'][i, k]) for k in range(num_slots) ], [tensor2im(output_dict['monet/x_input'][i])] + [ tensor2im(output_dict['monet/x_tilde'][i]) for k in range(num_slots - 1) ] ] montage = montage_fig(monet_fig) vis.row(id=i, image=fig, mask=montage) plt.close() with vis.table('Visualize #{} Trace'.format(visualized), [ HTMLTableColumnDesc('id', 'Step', 'text', {'width': '50px'}), HTMLTableColumnDesc('image', 'Image', 'figure', {'width': '600px'}), HTMLTableColumnDesc('p', 'operation', 'text', {'width': '200px'}), HTMLTableColumnDesc('r', 'result', 'code', {'width': '200px'}) ]): # TODO(Jiayuan Mao @ 11/20): support output_dict.programs. for j, (prog, buf) in enumerate( zip(feed_dict.program_seq[i], output_dict.buffers[i])): if j != len(feed_dict.program_seq[i]) - 1 and ( buf > 0 ).long().sum().item() > 0 and buf.size( 0) == feed_dict.objects_raw[i].shape[0]: this_objects = feed_dict.objects_raw[i][ torch.nonzero(buf > 0)[:, 0].numpy()] fig, ax = vis_bboxes(image, this_objects, 'object', add_text=False) else: fig, ax = vis_bboxes(image, [], 'object', add_text=False) vis.row(id=j, image=fig, p=repr(prog), r=repr(buf)) plt.close() visualized += 1 if visualized > args.nr_visualize: raise StopIteration() pbar.set_description( meters.format_simple( 'Epoch {} (validation)'.format(epoch), { k: v for k, v in meters.val.items() if k.startswith('validation') and k.count('/') <= 1 }, compressed=True)) pbar.update() end = time.time() except StopIteration: pass from jacinle.utils.meta import dict_deep_kv from jacinle.utils.printing import kvformat with vis.table('Info', [ HTMLTableColumnDesc('name', 'Name', 'code', {}), HTMLTableColumnDesc('info', 'KV', 'code', {}) ]): vis.row(name='args', info=kvformat(args.__dict__, max_key_len=32)) vis.row(name='configs', info=kvformat(dict(dict_deep_kv(configs)), max_key_len=32)) vis.end_html() logger.info( 'Happy Holiday! You can find your result at "http://monday.csail.mit.edu/xiuming' + osp.realpath(args.vis_dir) + '".')
def validate_attribute(model, val_dataloader, meters, meter_prefix='validation', logger=None, output_attr_path=''): end = time.time() video_num = len(val_dataloader) #pdb.set_trace() with tqdm_pbar(total=int(len(val_dataloader) * args.batch_size / 128)) as pbar: output_dict_list = [] frame_id_list = [] for feed_dict_list in val_dataloader: #for vid in range(video_num): end_frm_flag = False #while (not end_frm_flag): for idx, feed_dict in enumerate(feed_dict_list): scene_idx = feed_dict['meta_ann']['scene_index'] full_path = os.path.join( output_attr_path, 'attribute_' + str(scene_idx).zfill(5) + '.json') if os.path.isfile(full_path): print('File exists. %s\n' % (full_path)) tmp_dict = jsonload(full_path) if len(tmp_dict) == len( feed_dict['tube_info']['box_seq']['tubes'][0]): continue print('size didn\'t match. %s\n' % (full_path)) #pdb.set_trace() if args.use_gpu: if not args.gpu_parallel: feed_dict = async_copy_to(feed_dict, 0) frm_id = feed_dict['frm_id'] data_time = time.time() - end end = time.time() f_scene = model.resnet(feed_dict['img']) f_sng = model.scene_graph(f_scene, feed_dict) output_dict = parse_scene(feed_dict, f_sng, model.reasoning.embedding_attribute, frm_id) #pdb.set_trace() output_dict_list.append(output_dict) frame_id_list.append(frm_id) step_time = time.time() - end end = time.time() if frm_id == len( feed_dict['tube_info']['box_seq']['tubes'][0]) - 1: video_attr_list = [] for idx, result_dict in enumerate(output_dict_list): mon_dict = result_dict.pop('monitors') result_dict['frm_id'] = frame_id_list[idx] video_attr_list.append(result_dict) monitors = { meter_prefix + '/' + k: v for k, v in as_float(mon_dict).items() } n = 1 meters.update(monitors, n=n) meters.update({ 'time/data': data_time, 'time/step': step_time }) jsondump(full_path, video_attr_list) if args.use_tb: meters.flush() pbar.set_description( meters.format_simple('({})'.format(args.setname), { k: v for k, v in meters.val.items() if k.startswith('validation') and k.count('/') <= 2 }, compressed=True)) pbar.update() end = time.time() output_dict_list = [] frame_id_list = [] if logger is not None: logger.critical( meters.format_simple(meter_prefix, { k: v for k, v in meters.avg.items() if v != 0 }, compressed=False))