def main(): params = Params() paramparse.process(params) # for _sub_seq in params.sub_seq_dict: # params.sub_seq = _sub_seq # _convert_dataset(params) _convert_dataset(params)
def main(): params = Params() paramparse.process(params, allow_unknown=1) params.scp.read_auth() if params.working_dir: os.chdir(params.working_dir) timestamp = datetime.now().strftime("%y%m%d_%H%M%S_%f") log_data_all = [] log_data_dict = {} out_dir = linux_path(params.log_dir, 'consolidate_log') os.makedirs(out_dir, exist_ok=True) for server_id, server_name in enumerate(params.servers): log_path = run_scp(params.scp, server_name, params.log_dir, params.log_fname, out_dir, is_file=1, timestamp=timestamp) if log_path is None: print('log data for server {} not found'.format(server_name)) continue log_data = open(log_path, 'r').readlines() if server_id > 0 and params.remove_header: log_data = log_data[1:] log_data_all += log_data log_data_dict[server_name] = log_data # out_fname = add_suffix(params.log_fname, '{}'.format(timestamp)) out_fname = 'consolidated_{}.log'.format(timestamp) out_path = linux_path(out_dir, out_fname) print('writing consolidated log to {}'.format(out_path)) os.makedirs(params.log_dir, exist_ok=True) with open(out_path, 'w') as fid: fid.write(''.join(log_data_all)) open_cmd = "start {}".format(out_path) os.system(open_cmd) _ = input('press enter to exit')
def main(): params = Params() paramparse.process(params, allow_unknown=1) params.scp.read_auth() if params.working_dir: os.chdir(params.working_dir) timestamp = datetime.now().strftime("%y%m%d_%H%M%S_%f") while True: print('\n' + timestamp + '\n') run_scp(params.scp)
def main(): params = Params() process(params) src_path = params.src_path if not src_path: try: from Tkinter import Tk except ImportError: from tkinter import Tk try: src_path = Tk().clipboard_get() except BaseException as e: print('Tk().clipboard_get() failed: {}'.format(e)) return src_path = src_path.replace(os.sep, '/').replace('"', '') assert os.path.exists(src_path), "src_path does not exist: {}".format( src_path) src_dir = os.path.dirname(src_path) src_name = os.path.basename(src_path) src_name_noext, src_ext = os.path.splitext(src_name) out_name = src_name_noext + '_' + src_ext out_path = os.path.join(src_dir, out_name) assert not os.path.exists(out_path), "out_path already exists" img = cv2.imread(src_path) img_h, img_w = img.shape[:2] out_h = out_w = 0 if img_h > img_w: out_h = params.out_size else: out_w = params.out_size resized_img = resizeAR(img, width=out_w, height=out_h) cv2.imwrite(out_path, resized_img)
def main(): params = RTPNParams() paramparse.process(params) root_dir = params.root_dir io_file = params.io_file src_file_path = params.src_file_path if root_dir: src_file_path = os.path.join(root_dir, src_file_path) io_file = os.path.join(root_dir, io_file) src_file_path = os.path.abspath(src_file_path) with open(io_file, 'r') as fid: io_lines = fid.readlines() io_lines = [ k.strip() for k in io_lines if k.strip() and not k.startswith('#') ] io_str = '\n'.join(io_lines) io_str = '[{}]'.format(io_str.strip()) ops = literal_eval(io_str) # io_dict = json.load(fid) src_book = load_workbook(src_file_path) for op in ops: process_io_dict(op, src_book) if not params.in_place: src_file_name = os.path.splitext(os.path.basename(src_file_path))[0] src_file_dir = os.path.dirname(src_file_path) dst_file_name = src_file_name + '_proc.xlsx' dst_file_path = os.path.join(src_file_dir, dst_file_name) src_book.save(dst_file_path) else: # dst_file_path = src_file_path src_book.save(src_file_path)
def main(): params = Params() paramparse.process(params) list_fname = params.list_fname while True: if os.path.isfile(list_fname): print('reading tb log dir list from: {}'.format(list_fname)) data = open(list_fname, 'r').readlines() data_list = [k.strip().split('\t') for k in data] if params.start_id > 0: data_list = data_list[params.start_id:] data_list_str = ['{}:{}'.format(k[0], k[1]) for k in data_list if os.path.isdir(k[1])] log_dirs = ','.join(data_list_str) log_dirs_arg = '--logdir_spec' else: log_dirs = list_fname log_dirs_arg = '--logdir' tb_cmd = "{} {} {}={} --bind_all --samples_per_plugin images={}".format( params.python_exe, params.tb_path, log_dirs_arg, log_dirs, params.images, ) print('running: {}'.format(tb_cmd)) os.system(tb_cmd) list_fname = input('\nEnter log folder / list file name\n') if not list_fname.strip(): list_fname = params.list_fname
def main(): params = NewDeeplabParams() paramparse.process(params) params.process() phases = params.phases if params.start > 0: phases = phases[params.start:] if params.gpu: os.environ["CUDA_VISIBLE_DEVICES"] = params.gpu if Phases.train in phases: train.run(params.train) if Phases.raw_vis in phases: raw_vis.run(params.raw_vis) if Phases.stitch in phases: stitch.run(params.stitch) if Phases.vis in phases: vis.run(params.vis)
def main(): # parser = argparse.ArgumentParser(description="PyTorch DeeplabV3Plus Training") # parser.add_argument('--backbone', type=str, default='resnet', # choices=['resnet', 'xception', 'drn', 'mobilenet'], # help='backbone name (default: resnet)') # parser.add_argument('--out_stride', type=int, default=16, # help='network output stride (default: 8)') # parser.add_argument('--dataset', type=str, default='pascal', # choices=['pascal', 'coco', 'cityscapes'], # help='dataset name (default: pascal)') # parser.add_argument('--use_sbd', action='store_true', default=False, # help='whether to use SBD dataset (default: True)') # parser.add_argument('--workers', type=int, default=4, # metavar='N', help='dataloader threads') # parser.add_argument('--base_size', type=int, default=320, # help='base image size') # parser.add_argument('--crop_size', type=int, default=320, # help='crop image size') # parser.add_argument('--resize', type=int, default=512, # help='resize image size') # parser.add_argument('--sync_bn', type=bool, default=None, # help='whether to use sync bn (default: auto)') # parser.add_argument('--freeze_bn', type=bool, default=False, # help='whether to freeze bn parameters (default: False)') # parser.add_argument('--loss_type', type=str, default='ce', # choices=['ce', 'focal'], # help='loss func type (default: ce)') # # training hyper params # parser.add_argument('--epochs', type=int, default=None, metavar='N', # help='number of epochs to train (default: auto)') # parser.add_argument('--start_epoch', type=int, default=0, # metavar='N', help='start epochs (default:0)') # parser.add_argument('--batch_size', type=int, default=None, # metavar='N', help='input batch size for \ # training (default: auto)') # parser.add_argument('--test_batch_size', type=int, default=None, # metavar='N', help='input batch size for \ # testing (default: auto)') # parser.add_argument('--use_balanced_weights', action='store_true', default=False, # help='whether to use balanced weights (default: False)') # # optimizer params # parser.add_argument('--lr', type=float, default=0.025, metavar='LR', # help='learning rate (default: auto)') # parser.add_argument('--arch_lr', type=float, default=3e-3, # help='learning rate for alpha and beta in architect searching process') # # parser.add_argument('--lr_scheduler', type=str, default='cos', # choices=['poly', 'step', 'cos'], # help='lr scheduler mode: (default: cos)') # parser.add_argument('--momentum', type=float, default=0.9, # metavar='M', help='momentum (default: 0.9)') # parser.add_argument('--weight_decay', type=float, default=3e-4, # metavar='M', help='w-decay (default: 5e-4)') # parser.add_argument('--arch_weight_decay', type=float, default=1e-3, # metavar='M', help='w-decay (default: 5e-4)') # # parser.add_argument('--nesterov', action='store_true', default=False, # help='whether use nesterov (default: False)') # # cuda, seed and logging # parser.add_argument('--no_cuda', action='store_true', default= # False, help='disables CUDA training') # parser.add_argument('--gpu-ids', nargs='*', type=int, default=0, # help='which GPU to train on (default: 0)') # parser.add_argument('--seed', type=int, default=1, metavar='S', # help='random seed (default: 1)') # # checking point # parser.add_argument('--resume', type=str, default=None, # help='put the path to resuming file if needed') # parser.add_argument('--checkname', type=str, default=None, # help='set the checkpoint name') # # finetuning pre-trained models # parser.add_argument('--ft', action='store_true', default=False, # help='finetuning on a different dataset') # # evaluation option # parser.add_argument('--eval_interval', type=int, default=1, # help='evaluuation interval (default: 1)') # parser.add_argument('--no_val', action='store_true', default=False, # help='skip validation during training') # # paramparse.fromParser(parser, 'AutoDeeplabParams') # # args = parser.parse_args() args = AutoDeeplabParams() paramparse.process(args) args.cuda = not args.no_cuda and torch.cuda.is_available() if args.sync_bn is None: if args.cuda and len(args.gpu_ids) > 1: args.sync_bn = True else: args.sync_bn = False # default settings for epochs, batch_size and lr if args.epochs is None: epoches = { 'coco': 30, 'cityscapes': 200, 'pascal': 50, } args.epochs = epoches[args.dataset.lower()] if args.batch_size is None: args.batch_size = 4 * len(args.gpu_ids) if args.test_batch_size is None: args.test_batch_size = args.batch_size if args.lr is None: lrs = { 'coco': 0.1, 'cityscapes': 0.025, 'pascal': 0.007, } # args.lr = lrs[args.dataset.lower()] / (4 * len(args.gpu_ids)) * args.batch_size if args.checkname is None: args.checkname = 'deeplab-' + str(args.backbone) print(args) torch.manual_seed(args.seed) trainer = Trainer(args) print('Starting Epoch:', trainer.args.start_epoch) print('Total Epoches:', trainer.args.epochs) for epoch in range(trainer.args.start_epoch, trainer.args.epochs): trainer.training(epoch) if not trainer.args.no_val and epoch % args.eval_interval == ( args.eval_interval - 1): trainer.validation(epoch) trainer.writer.close()
def main(): params = Params() paramparse.process(params) root_dirs = params.root_dirs annotations = params.annotations save_path = params.save_path img_ext = params.img_ext show_img = params.show_img del_src = params.del_src start_id = params.start_id n_frames = params.n_frames width = params.width height = params.height fps = params.fps codec = params.codec ext = params.ext out_width = params.out_width out_height = params.out_height grid_size = params.grid_size sep_size = params.sep_size only_height = params.only_height borderless = params.borderless preserve_order = params.preserve_order ann_fmt = params.ann_fmt resize_factor = params.resize_factor recursive = params.recursive img_seq = params.img_seq match_images = params.match_images if match_images: assert img_seq, "image matching is only supported in image sequence mode" vid_exts = ['.mkv', '.mp4', '.avi', '.mjpg', '.wmv'] image_exts = ['.jpg', '.bmp', '.png', '.tif'] min_n_sources = None min_sources = None min_sources_id = None sources_list = [] for root_dir_id, root_dir in enumerate(root_dirs): root_dir = os.path.abspath(root_dir) if img_seq: sources = [k for k in os.listdir(root_dir) if os.path.isdir(os.path.join(root_dir, k))] else: sources = [k for k in os.listdir(root_dir) if os.path.splitext(k)[1] in vid_exts] sources.sort() n_sources = len(sources) if min_n_sources is None or n_sources < min_n_sources: min_n_sources = n_sources min_sources = sources min_sources_id = root_dir_id sources = [os.path.join(root_dir, k) for k in sources] sources_list.append(sources) if match_images: for sources_id, sources in enumerate(sources_list): if sources_id == min_sources_id: continue sources = [k for k in sources if os.path.basename(k) in min_sources] assert len(sources) == min_n_sources, "invalid sources after filtering {}".format(sources) sources_list[sources_id] = sources src_paths = list(zip(*sources_list)) print('sources_list:\n{}'.format(pformat(sources_list))) print('src_paths:\n{}'.format(pformat(src_paths))) timestamp = datetime.now().strftime("%y%m%d_%H%M%S") _exit = 0 for _src_path in src_paths: _annotations = annotations _save_path = save_path _grid_size = grid_size n_frames = 0 src_files = _src_path n_videos = len(src_files) assert n_videos > 0, 'no input videos found' if not _save_path: seq_dir = os.path.dirname(src_files[0]) seq_name = os.path.splitext(os.path.basename(src_files[0]))[0] dst_path = os.path.join(seq_dir, 'stacked_{}'.format(timestamp), '{}.{}'.format(seq_name, ext)) else: out_seq_name, out_ext = os.path.splitext(os.path.basename(_save_path)) dst_path = os.path.join(os.path.dirname(_save_path), '{}_{}{}'.format( out_seq_name, datetime.now().strftime("%y%m%d_%H%M%S"), out_ext)) save_dir = os.path.dirname(dst_path) if save_dir and not os.path.isdir(save_dir): os.makedirs(save_dir) print('Stacking: {} videos:'.format(n_videos)) print('src_files:\n{}'.format(pformat(src_files))) if _annotations: if len(_annotations) == 1 and _annotations[0] == 1: _annotations = [] for i in range(n_videos): _annotations.append(seq_names[i]) else: assert len(_annotations) == n_videos, 'Invalid annotations: {}'.format(_annotations) for i in range(n_videos): if _annotations[i] == '__n__': _annotations[i] = '' print('Adding annotations:\n{}'.format(pformat(_annotations))) else: _annotations = None if not _grid_size: _grid_size = None else: _grid_size = [int(x) for x in _grid_size.split('x')] if len(_grid_size) != 2 or _grid_size[0] * _grid_size[1] != n_videos: raise AssertionError('Invalid grid_size: {}'.format(_grid_size)) n_frames_list = [] cap_list = [] size_list = [] seq_names = [] min_n_frames = None min_n_frames_id = 0 for src_id, src_file in enumerate(src_files): src_file = os.path.abspath(src_file) seq_name = os.path.splitext(os.path.basename(src_file))[0] seq_names.append(seq_name) if os.path.isfile(src_file): cap = cv2.VideoCapture() elif os.path.isdir(src_file): cap = ImageSequenceCapture(src_file, recursive=recursive) else: raise IOError('Invalid src_file: {}'.format(src_file)) if not cap.open(src_file): raise IOError('The video file ' + src_file + ' could not be opened') cv_prop = cv2.CAP_PROP_FRAME_COUNT h_prop = cv2.CAP_PROP_FRAME_HEIGHT w_prop = cv2.CAP_PROP_FRAME_WIDTH total_frames = int(cap.get(cv_prop)) _height = int(cap.get(h_prop)) _width = int(cap.get(w_prop)) cap_list.append(cap) n_frames_list.append(total_frames) if min_n_frames is None or total_frames < min_n_frames: min_n_frames = total_frames min_n_frames_id = src_id size_list.append((_width, _height)) if match_images: assert all(seq_name == seq_names[0] for seq_name in seq_names), "mismatch in seq_names: {}".format(seq_names) frames_list = [os.path.basename(k) for k in cap_list[min_n_frames_id].src_files] for src_id, cap in enumerate(cap_list): if src_id == min_n_frames_id: continue cap_list[src_id].filter_files(frames_list) n_frames_list[src_id] = min_n_frames frame_id = start_id pause_after_frame = 0 video_out = None win_name = 'stacked_{}'.format(datetime.now().strftime("%y%m%d_%H%M%S")) min_n_frames = min(n_frames_list) max_n_frames = max(n_frames_list) if n_frames <= 0: n_frames = max_n_frames else: if max_n_frames < n_frames: raise IOError( 'Invalid n_frames: {} for sequence list with max_n_frames: {}'.format(n_frames, max_n_frames)) if show_img == 2: vis_only = True print('Running in visualization only mode') else: vis_only = False while True: images = [] valid_caps = [] valid_annotations = [] for cap_id, cap in enumerate(cap_list): ret, image = cap.read() if not ret: print('\nFrame {:d} could not be read'.format(frame_id + 1)) continue images.append(image) valid_caps.append(cap) if _annotations: valid_annotations.append(_annotations[cap_id]) cap_list = valid_caps if _annotations: _annotations = valid_annotations # if len(images) != n_videos: # break frame_id += 1 if frame_id <= start_id: break out_img = stackImages(images, _grid_size, borderless=borderless, preserve_order=preserve_order, annotations=_annotations, ann_fmt=ann_fmt, only_height=only_height, sep_size=sep_size) if resize_factor != 1: out_img = cv2.resize(out_img, (0, 0), fx=resize_factor, fy=resize_factor) if not vis_only: if video_out is None: dst_height, dst_width = sizeAR(out_img, width=out_width, height=out_height) if '.' + ext in vid_exts: fourcc = cv2.VideoWriter_fourcc(*codec) video_out = cv2.VideoWriter(dst_path, fourcc, fps, (dst_width, dst_height)) elif '.' + ext in image_exts: video_out = ImageSequenceWriter(dst_path, height=dst_height, width=dst_width) else: raise IOError('Invalid ext: {}'.format(ext)) if video_out is None: raise IOError('Output video file could not be opened: {}'.format(dst_path)) print('Saving {}x{} output video to {}'.format(dst_width, dst_height, dst_path)) out_img = resizeAR(out_img, width=dst_width, height=dst_height) video_out.write(out_img) if show_img: # out_img_disp = out_img out_img_disp = resizeAR(out_img, 1280) cv2.imshow(win_name, out_img_disp) k = cv2.waitKey(1 - pause_after_frame) & 0xFF if k == ord('q'): _exit = 1 break elif k == 27: break elif k == 32: pause_after_frame = 1 - pause_after_frame sys.stdout.write('\rDone {:d}/{:d} frames '.format(frame_id - start_id, n_frames)) sys.stdout.flush() if frame_id - start_id >= n_frames: break if _exit: break sys.stdout.write('\n') sys.stdout.flush() video_out.release() if show_img: cv2.destroyWindow(win_name)
out_txt = copy_from_clipboard() # print('out_txt: {}'.format(out_txt)) else: key = load_key(params.key_file) decrypted_data = decrypt(params.in_file, key) out_txt = decrypted_data.decode('ascii') # print('out_txt: {}'.format(out_txt)) if params.clipboard: if params.clipboard == 1: copy_to_clipboard(out_txt) elif params.clipboard == 2: type_string( out_txt, # params.auto_switch, press_enter=params.press_enter) else: # write the original file with open(params.out_file, "wb") as file: file.write(decrypted_data) return out_txt if __name__ == '__main__': _params = Params() paramparse.process(_params) _params.process() run(_params)
def main(): _params = Params() paramparse.process(_params) root_dir = _params.root_dir start_id = _params.start_id end_id = _params.end_id write_img = _params.write_img write_gt = _params.write_gt save_img = _params.save_img save_vid = _params.save_vid codec = _params.codec show_img = _params.show_img vis_height = _params.vis_height vis_width = _params.vis_width # default_obj_size = _params.default_obj_size ignore_missing_gt = _params.ignore_missing_gt ignore_missing_seg = _params.ignore_missing_seg raad_gt = _params.raad_gt if save_img: if not show_img: show_img += 2 else: if show_img > 1: save_img = 1 params = ParamDict() actor = 'CTC' actor_sequences_dict = params.sequences_ctc actor_sequences = list(actor_sequences_dict.keys()) if end_id <= start_id: end_id = len(actor_sequences) - 1 print('root_dir: {}'.format(root_dir)) print('start_id: {}'.format(start_id)) print('end_id: {}'.format(end_id)) print('actor: {}'.format(actor)) print('actor_sequences: {}'.format(actor_sequences)) img_exts = ('.tif', ) n_frames_list = [] _pause = 1 __pause = 1 ann_cols = ('green', 'blue', 'red', 'cyan', 'magenta', 'gold', 'purple', 'peach_puff', 'azure', 'dark_slate_gray', 'navy', 'turquoise') out_img_tif_root_path = linux_path(root_dir, actor, 'Images_TIF') os.makedirs(out_img_tif_root_path, exist_ok=True) out_img_jpg_root_path = linux_path(root_dir, actor, 'Images') os.makedirs(out_img_jpg_root_path, exist_ok=True) if save_img: out_vis_root_path = linux_path(root_dir, actor, 'Visualizations') os.makedirs(out_vis_root_path, exist_ok=True) out_gt_root_path = linux_path(root_dir, actor, 'Annotations') os.makedirs(out_gt_root_path, exist_ok=True) n_frames_out_file = linux_path(root_dir, actor, 'n_frames.txt') n_frames_out_fid = open(n_frames_out_file, 'w') _exit = 0 _pause = 1 time_stamp = datetime.now().strftime("%y%m%d_%H%M%S") log_path = linux_path(root_dir, actor, 'log_{}.log'.format(time_stamp)) tif_root_dir = linux_path(root_dir, actor, 'tif') assert os.path.exists(tif_root_dir), "tif_root_dir does not exist" seq_ids = _params.seq_ids if not seq_ids: seq_ids = list(range(start_id, end_id + 1)) n_seq = len(seq_ids) for __id, seq_id in enumerate(seq_ids): seq_name = actor_sequences[seq_id] default_obj_size = actor_sequences_dict[seq_name] seq_img_path = linux_path(tif_root_dir, seq_name) assert os.path.exists(seq_img_path), "seq_img_path does not exist" seq_img_src_files = [ k for k in os.listdir(seq_img_path) if os.path.splitext(k.lower())[1] in img_exts ] seq_img_src_files.sort() out_gt_fid = None n_frames = len(seq_img_src_files) print('seq {} / {}\t{}\t{}\t{} frames'.format(__id + 1, n_seq, seq_id, seq_name, n_frames)) n_frames_out_fid.write("{:d}: ('{:s}', {:d}),\n".format( seq_id, seq_name, n_frames)) n_frames_list.append(n_frames) gt_available = 0 if not raad_gt: print('skipping GT reading') else: seq_gt_path = linux_path(tif_root_dir, seq_name + '_GT', 'TRA') if not os.path.exists(seq_gt_path): msg = "seq_gt_path does not exist" if ignore_missing_gt: print(msg) else: raise AssertionError(msg) else: gt_available = 1 seq_gt_tra_file = linux_path(seq_gt_path, "man_track.txt") if os.path.exists(seq_gt_tra_file): out_tra_file = linux_path(out_gt_root_path, seq_name + '.tra') print('{} --> {}'.format(seq_gt_tra_file, out_tra_file)) if not os.path.exists(out_tra_file): shutil.copy(seq_gt_tra_file, out_tra_file) else: print('skipping existing {}'.format(out_tra_file)) else: msg = "\nseq_gt_tra_file does not exist: {}".format( seq_gt_tra_file) if ignore_missing_gt: print(msg) else: raise AssertionError(msg) if _params.tra_only: continue seg_available = 0 if not raad_gt: print('skipping segmentation reading') else: seq_seg_path = linux_path(tif_root_dir, seq_name + '_ST', 'SEG') if not os.path.exists(seq_seg_path): print("ST seq_seg_path does not exist") seq_seg_path = linux_path(tif_root_dir, seq_name + '_GT', 'SEG') if not os.path.exists(seq_seg_path): msg = "GT seq_seg_path does not exist" if ignore_missing_seg: print(msg) else: raise AssertionError(msg) else: seg_available = 1 else: seg_available = 1 if write_img: out_img_tif_dir_path = linux_path(out_img_tif_root_path, seq_name) os.makedirs(out_img_tif_dir_path, exist_ok=True) print('copying TIF images to {}'.format(out_img_tif_dir_path)) out_img_jpg_dir_path = linux_path(out_img_jpg_root_path, seq_name) os.makedirs(out_img_jpg_dir_path, exist_ok=True) print('Saving jPG images to {}'.format(out_img_jpg_dir_path)) vid_out = None if save_img: if save_vid: out_vis_path = linux_path(out_vis_root_path, seq_name + '.mkv') vid_out = cv2.VideoWriter(out_vis_path, cv2.VideoWriter_fourcc(*codec), 30, (vis_width, vis_height)) else: out_vis_path = linux_path(out_vis_root_path, seq_name) os.makedirs(out_vis_path, exist_ok=True) print('Saving visualizations to {}'.format(out_vis_path)) from collections import OrderedDict file_id_to_gt = OrderedDict() obj_id_to_gt_file_ids = OrderedDict() if gt_available: print('reading GT from {}...'.format(seq_gt_path)) seq_gt_src_files = [ k for k in os.listdir(seq_gt_path) if os.path.splitext(k.lower())[1] in img_exts ] seq_gt_src_files.sort() assert len(seq_img_src_files) == len( seq_gt_src_files ), "mismatch between the lengths of seq_img_src_files and seq_gt_src_files" for seq_gt_src_file in tqdm(seq_gt_src_files, disable=_params.disable_tqdm): seq_gt_src_file_id = ''.join(k for k in seq_gt_src_file if k.isdigit()) file_id_to_gt[seq_gt_src_file_id] = OrderedDict() seq_gt_src_path = os.path.join(seq_gt_path, seq_gt_src_file) seq_gt_pil = Image.open(seq_gt_src_path) seq_gt_np = np.array(seq_gt_pil) gt_obj_ids = list(np.unique(seq_gt_np, return_counts=False)) gt_obj_ids.remove(0) for obj_id in gt_obj_ids: obj_locations = np.nonzero(seq_gt_np == obj_id) centroid_y, centroid_x = [ np.mean(k) for k in obj_locations ] file_id_to_gt[seq_gt_src_file_id][obj_id] = [ obj_locations, centroid_y, centroid_x ] if obj_id not in obj_id_to_gt_file_ids: obj_id_to_gt_file_ids[obj_id] = [] obj_id_to_gt_file_ids[obj_id].append(seq_gt_src_file_id) if write_gt: out_gt_path = linux_path(out_gt_root_path, seq_name + '.txt') out_gt_fid = open(out_gt_path, 'w') file_id_to_seg = OrderedDict() file_id_to_nearest_seg = OrderedDict() obj_id_to_seg_file_ids = OrderedDict() obj_id_to_seg_sizes = OrderedDict() obj_id_to_seg_bboxes = OrderedDict() obj_id_to_mean_seg_sizes = OrderedDict() obj_id_to_max_seg_sizes = OrderedDict() all_seg_sizes = [] mean_seg_sizes = None max_seg_sizes = None if seg_available: print('reading segmentations from {}...'.format(seq_seg_path)) seq_seq_src_files = [ k for k in os.listdir(seq_seg_path) if os.path.splitext(k.lower())[1] in img_exts ] for seq_seq_src_file in tqdm(seq_seq_src_files, disable=_params.disable_tqdm): seq_seq_src_file_id = ''.join(k for k in seq_seq_src_file if k.isdigit()) file_gt = file_id_to_gt[seq_seq_src_file_id] file_id_to_seg[seq_seq_src_file_id] = OrderedDict() seq_seq_src_path = os.path.join(seq_seg_path, seq_seq_src_file) seq_seg_pil = Image.open(seq_seq_src_path) seq_seg_np = np.array(seq_seg_pil) seg_obj_ids = list(np.unique(seq_seg_np, return_counts=False)) seg_obj_ids.remove(0) _gt_obj_ids = list(file_gt.keys()) if len(_gt_obj_ids) != len(seg_obj_ids): print( "\nmismatch between the number of objects in segmentation: {} and GT: {} in {}" .format(len(seg_obj_ids), len(_gt_obj_ids), seq_seq_src_file)) from scipy.spatial import distance_matrix seg_centroids = [] seg_id_to_locations = {} for seg_obj_id in seg_obj_ids: # obj_id = gt_obj_ids[seg_obj_id - 1] seg_obj_locations = np.nonzero(seq_seg_np == seg_obj_id) seg_centroid_y, seg_centroid_x = [ np.mean(k) for k in seg_obj_locations ] seg_centroids.append([seg_centroid_y, seg_centroid_x]) seg_id_to_locations[seg_obj_id] = seg_obj_locations gt_centroids = [[k[1], k[2]] for k in file_gt.values()] gt_centroids = np.asarray(gt_centroids) seg_centroids = np.asarray(seg_centroids) gt_to_seg_dists = distance_matrix(seg_centroids, gt_centroids) # seg_min_dist_ids = np.argmin(gt_to_seg_dists, axis=1) # gt_min_dist_ids = np.argmin(gt_to_seg_dists, axis=0) # unique_min_dist_ids = np.unique(seg_min_dist_ids) # # # assert len(unique_min_dist_ids) == len(seg_min_dist_ids), \ # "duplicate matches found between segmentation and GT objects" # seg_to_gt_obj_ids = { # seg_obj_id: _gt_obj_ids[seg_min_dist_ids[_id]] for _id, seg_obj_id in enumerate(seg_obj_ids) # } from scipy.optimize import linear_sum_assignment seg_inds, gt_inds = linear_sum_assignment(gt_to_seg_dists) if len(seg_inds) != len(seg_obj_ids): print( "only {} / {} segmentation objects assigned to GT objects" .format(len(seg_inds), len(seg_obj_ids))) seg_to_gt_obj_ids = { seg_obj_ids[seg_inds[i]]: _gt_obj_ids[gt_inds[i]] for i in range(len(seg_inds)) } # print() for seg_obj_id in seg_obj_ids: seg_obj_locations = seg_id_to_locations[seg_obj_id] _gt_obj_id = seg_to_gt_obj_ids[seg_obj_id] min_y, min_x = [np.amin(k) for k in seg_obj_locations] max_y, max_x = [np.amax(k) for k in seg_obj_locations] size_x, size_y = max_x - min_x, max_y - min_y if _gt_obj_id not in obj_id_to_seg_sizes: obj_id_to_seg_bboxes[_gt_obj_id] = [] obj_id_to_seg_sizes[_gt_obj_id] = [] obj_id_to_seg_file_ids[_gt_obj_id] = [] obj_id_to_seg_file_ids[_gt_obj_id].append( seq_seq_src_file_id) file_id_to_seg[seq_seq_src_file_id][_gt_obj_id] = ( seg_obj_locations, [min_x, min_y, max_x, max_y]) obj_id_to_seg_bboxes[_gt_obj_id].append( [seq_seq_src_file, min_x, min_y, max_x, max_y]) obj_id_to_seg_sizes[_gt_obj_id].append([size_x, size_y]) all_seg_sizes.append([size_x, size_y]) obj_id_to_mean_seg_sizes = OrderedDict({ k: np.mean(v, axis=0) for k, v in obj_id_to_seg_sizes.items() }) obj_id_to_max_seg_sizes = OrderedDict({ k: np.amax(v, axis=0) for k, v in obj_id_to_seg_sizes.items() }) print('segmentations found for {} files'.format( len(file_id_to_seg), # '\n'.join(file_id_to_seg.keys()) )) print('segmentations include {} objects:\n{}'.format( len(obj_id_to_seg_bboxes), ', '.join(str(k) for k in obj_id_to_seg_bboxes.keys()))) mean_seg_sizes = np.mean(all_seg_sizes, axis=0) max_seg_sizes = np.amax(all_seg_sizes, axis=0) for obj_id in obj_id_to_seg_file_ids: seg_file_ids = obj_id_to_seg_file_ids[obj_id] seg_file_ids_num = np.asarray( list(int(k) for k in seg_file_ids)) gt_file_ids = obj_id_to_gt_file_ids[obj_id] # gt_file_ids_num = np.asarray(list(int(k) for k in gt_file_ids)) gt_seg_file_ids_dist = { gt_file_id: np.abs(int(gt_file_id) - seg_file_ids_num) for gt_file_id in gt_file_ids } file_id_to_nearest_seg[obj_id] = { gt_file_id: seg_file_ids[np.argmin(_dist).item()] for gt_file_id, _dist in gt_seg_file_ids_dist.items() } nearest_seg_size = OrderedDict() for frame_id in tqdm(range(n_frames), disable=_params.disable_tqdm): seq_img_src_file = seq_img_src_files[frame_id] # assert seq_img_src_file in seq_gt_src_file, \ # "mismatch between seq_img_src_file and seq_gt_src_file" seq_img_src_file_id = ''.join(k for k in seq_img_src_file if k.isdigit()) seq_img_src_path = os.path.join(seq_img_path, seq_img_src_file) # seq_img_pil = Image.open(seq_img_src_path) # seq_img = np.array(seq_img_pil) seq_img = cv2.imread(seq_img_src_path, cv2.IMREAD_UNCHANGED) # assert (seq_img == seq_img_cv).all(), "mismatch between PIL and cv2 arrays" # seq_img_cv_unique = np.unique(seq_img_cv) # n_seq_img_unique_cv = len(seq_img_cv_unique) # seq_img_float = seq_img.astype(np.float32) / 65535. max_pix, min_pix = np.amax(seq_img), np.amin(seq_img) seq_img_float_norm = (seq_img.astype(np.float32) - min_pix) / (max_pix - min_pix) seq_img_uint8 = (seq_img_float_norm * 255.).astype(np.uint8) # seq_img_uint8 = (seq_img / 256.).astype(np.uint8) max_pix_uint8, min_pix_uint8 = np.amax(seq_img_uint8), np.amin( seq_img_uint8) seq_img_unique = np.unique(seq_img) seq_img_unique_uint8 = np.unique(seq_img_uint8) n_seq_img_unique = len(seq_img_unique) n_seq_img_unique_uint8 = len(seq_img_unique_uint8) if n_seq_img_unique > n_seq_img_unique_uint8: # print('{} :: drop in number of unique values from {} ({}, {}) to {} ({}, {})'.format( # seq_img_src_file, n_seq_img_unique, max_pix, min_pix, # n_seq_img_unique_uint8, max_pix_uint8, min_pix_uint8)) with open(log_path, 'a') as log_fid: log_fid.write('{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\n'.format( seq_name, seq_img_src_file, n_seq_img_unique, n_seq_img_unique_uint8, max_pix, min_pix, max_pix_uint8, min_pix_uint8)) # print() if write_img: # out_img_file = os.path.splitext(seq_img_src_file)[0] + '.png' # out_img_file_path = linux_path(out_img_tif_dir_path, out_img_file) out_img_file_tif = os.path.splitext( seq_img_src_file)[0] + '.tif' out_img_file_path_tif = linux_path(out_img_tif_dir_path, out_img_file_tif) out_img_file_uint8 = os.path.splitext( seq_img_src_file)[0] + '.jpg' out_img_file_path_uint8 = linux_path(out_img_jpg_dir_path, out_img_file_uint8) if not os.path.exists(out_img_file_path_uint8): # cv2.imwrite(out_img_file_path, seq_img) cv2.imwrite(out_img_file_path_uint8, seq_img_uint8) if not os.path.exists(out_img_file_path_tif): # print('{} --> {}'.format(seq_img_src_path, out_img_file_path_tif)) shutil.copyfile(seq_img_src_path, out_img_file_path_tif) if show_img: seq_img_col = seq_img_uint8.copy() if len(seq_img_col.shape) == 2: seq_img_col = cv2.cvtColor(seq_img_col, cv2.COLOR_GRAY2BGR) # seq_img_col2 = seq_img_col.copy() seq_img_col3 = seq_img_col.copy() if not gt_available: if save_img: if vid_out is not None: vid_out.write(seq_img_col) continue file_gt = file_id_to_gt[seq_img_src_file_id] # seq_gt_src_file = seq_gt_src_files[frame_id] # assert seq_gt_src_file_id == seq_img_src_file_id, \ # "Mismatch between seq_gt_src_file_id and seq_img_src_file_id" gt_obj_ids = list(file_gt.keys()) for obj_id in gt_obj_ids: assert obj_id != 0, "invalid object ID" try: nearest_seg_file_ids = file_id_to_nearest_seg[obj_id] except KeyError: file_seg = {} else: nearest_seg_file_id = nearest_seg_file_ids[ seq_img_src_file_id] file_seg = file_id_to_seg[nearest_seg_file_id] obj_locations, centroid_y, centroid_x = file_gt[obj_id] if file_seg: xmin, ymin, xmax, ymax = file_seg[obj_id][1] size_x, size_y = xmax - xmin, ymax - ymin nearest_seg_size[obj_id] = (size_x, size_y) else: try: size_x, size_y = nearest_seg_size[obj_id] except KeyError: try: size_x, size_y = obj_id_to_mean_seg_sizes[obj_id] except KeyError: if mean_seg_sizes is not None: size_x, size_y = mean_seg_sizes else: size_x, size_y = default_obj_size, default_obj_size ymin, xmin = centroid_y - size_y / 2.0, centroid_x - size_x / 2.0 ymax, xmax = centroid_y + size_y / 2.0, centroid_x + size_x / 2.0 width = int(xmax - xmin) height = int(ymax - ymin) if show_img: col_id = (obj_id - 1) % len(ann_cols) col = col_rgb[ann_cols[col_id]] drawBox(seq_img_col, xmin, ymin, xmax, ymax, label=str(obj_id), box_color=col) # seq_img_col2[obj_locations] = col if file_seg: try: locations, bbox = file_seg[obj_id][:2] except KeyError: print('weird stuff going on here') else: seq_img_col3[locations] = col # min_x, min_y, max_x, max_y = bbox # drawBox(seq_img_col3, min_x, min_y, max_x, max_y, label=str(obj_id), box_color=col) if write_gt: out_gt_fid.write( '{:d},{:d},{:.3f},{:.3f},{:d},{:d},1,-1,-1,-1\n'. format(frame_id + 1, obj_id, xmin, ymin, width, height)) # print() skip_seq = 0 if show_img: # images_to_stack = [seq_img_col, seq_img_col2] images_to_stack = [ seq_img_col, ] if file_seg: images_to_stack.append(seq_img_col3) __pause = _pause else: __pause = _pause seq_img_vis = stackImages(images_to_stack, sep_size=5) seq_img_vis = resizeAR(seq_img_vis, height=vis_height, width=vis_width) cv2.putText(seq_img_vis, '{}: {}'.format(seq_name, seq_img_src_file_id), (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1) if show_img != 2: cv2.imshow('seq_img_vis', seq_img_vis) k = cv2.waitKey(1 - __pause) if k == 32: _pause = 1 - _pause elif k == 27: skip_seq = 1 break elif k == ord('q'): break if save_img: if vid_out is not None: vid_out.write(seq_img_vis) else: out_vis_file = os.path.splitext( seq_img_src_file)[0] + '.jpg' out_vis_file_path = linux_path(out_vis_path, out_vis_file) cv2.imwrite(out_vis_file_path, seq_img_vis) if skip_seq or _exit: break if vid_out is not None: vid_out.release() if out_gt_fid is not None: out_gt_fid.close() if _exit: break n_frames_out_fid.close()
def main(): params = Params() paramparse.process(params)
def main(): params = A10_Params() train_params = params.train # optional command line argument parsing try: import paramparse except ImportError: pass else: paramparse.process(train_params) # init device if params.use_cuda and torch.cuda.is_available(): device = torch.device("cuda") print('Training on GPU: {}'.format(torch.cuda.get_device_name(0))) else: device = torch.device("cpu") print('Training on CPU') # load dataset train_set = FontsDataset() num_train = len(train_set) indices = list(range(num_train)) assert train_params.valid_ratio > 0, "Zero validation ratio is not allowed " split = int(np.floor((1.0 - train_params.valid_ratio) * num_train)) train_idx, valid_idx = indices[:split], indices[split:] print('Training samples: {}\n' 'Validation samples: {}\n' ''.format( len(train_idx), len(valid_idx), )) train_sampler = SubsetRandomSampler(train_idx) valid_sampler = SubsetRandomSampler(valid_idx) train_dataloader = torch.utils.data.DataLoader( train_set, batch_size=train_params.batch_size, sampler=train_sampler, num_workers=4) valid_dataloader = torch.utils.data.DataLoader(train_set, batch_size=24, sampler=valid_sampler, num_workers=4) # create modules classifier = Classifier().to(device) assert isinstance(classifier, nn.Module), 'classifier must be an instance of nn.Module' classifier.init_weights() # create losses criterion = torch.nn.CrossEntropyLoss().to(device) parameters = classifier.parameters() # create optimizer if train_params.optim_type == 0: optimizer = torch.optim.SGD(parameters, lr=train_params.lr, momentum=train_params.momentum, weight_decay=train_params.weight_decay) elif train_params.optim_type == 1: optimizer = torch.optim.Adam( parameters, lr=train_params.lr, weight_decay=train_params.weight_decay, eps=train_params.eps, ) else: raise IOError('Invalid optim_type: {}'.format(train_params.optim_type)) # optimizer = torch.optim.Adam(classifier.parameters()) weights_dir = os.path.dirname(train_params.weights_path) weights_name = os.path.basename(train_params.weights_path) if not os.path.isdir(weights_dir): os.makedirs(weights_dir) tb_path = os.path.join(weights_dir, 'tb') if not os.path.isdir(tb_path): os.makedirs(tb_path) writer = SummaryWriter(logdir=tb_path) print(f'Saving tensorboard summary to: {tb_path}') start_epoch = 0 max_valid_acc_epoch = 0 max_valid_acc = 0 max_train_acc = 0 min_valid_loss = np.inf min_train_loss = np.inf valid_loss = valid_acc = -1 # load weights if train_params.load_weights: matching_ckpts = [ k for k in os.listdir(weights_dir) if os.path.isfile(os.path.join(weights_dir, k)) and k.startswith(weights_name) ] if not matching_ckpts: msg = 'No checkpoints found matching {} in {}'.format( weights_name, weights_dir) if train_params.load_weights == 1: raise IOError(msg) print(msg) else: matching_ckpts.sort( key=lambda x: [int(c) if c.isdigit() else c for c in re.split(r'(\d+)', x)]) weights_path = os.path.join(weights_dir, matching_ckpts[-1]) chkpt = torch.load(weights_path, map_location=device) # load checkpoint print('Loading weights from: {} with:\n' '\tepoch: {}\n' '\ttrain_loss: {}\n' '\ttrain_acc: {}\n' '\tvalid_loss: {}\n' '\tvalid_acc: {}\n' '\ttimestamp: {}\n'.format(weights_path, chkpt['epoch'], chkpt['train_loss'], chkpt['train_acc'], chkpt['valid_loss'], chkpt['valid_acc'], chkpt['timestamp'])) classifier.load_state_dict(chkpt['classifier']) optimizer.load_state_dict(chkpt['optimizer']) max_valid_acc = chkpt['valid_acc'] min_valid_loss = chkpt['valid_loss'] max_train_acc = chkpt['train_acc'] min_train_loss = chkpt['train_loss'] max_valid_acc_epoch = chkpt['epoch'] start_epoch = chkpt['epoch'] + 1 if train_params.load_weights != 1: # start / continue training for epoch in range(start_epoch, train_params.n_epochs): # set CNN to training mode classifier.train() train_loss = 0 train_total = 0 train_correct = 0 batch_idx = 0 save_weights = 0 for batch_idx, (inputs, targets) in tqdm(enumerate(train_dataloader)): inputs = inputs.to(device) targets = targets.to(device) optimizer.zero_grad() outputs = classifier(inputs) loss = criterion(outputs, targets) mean_loss = loss.item() train_loss += mean_loss loss.backward() optimizer.step() _, predicted = outputs.max(1) train_total += targets.size(0) train_correct += predicted.eq(targets).sum().item() mean_train_loss = train_loss / (batch_idx + 1) train_acc = 100. * train_correct / train_total # write training data for tensorboard writer.add_scalar('train_loss', train_loss, epoch) writer.add_scalar('train_acc', train_acc, epoch) if epoch % train_params.valid_gap == 0: valid_loss, valid_acc, _ = evaluate(classifier, valid_dataloader, criterion, train_params.vis, device) if valid_acc > max_valid_acc: max_valid_acc = valid_acc max_valid_acc_epoch = epoch if train_params.save_criterion == 0: save_weights = 1 if valid_loss < min_valid_loss: min_valid_loss = valid_loss if train_params.save_criterion == 1: save_weights = 1 if train_acc > max_train_acc: max_train_acc = train_acc if train_params.save_criterion == 2: save_weights = 1 if train_loss < min_train_loss: min_train_loss = train_loss if train_params.save_criterion == 3: save_weights = 1 # write validation data for tensorboard writer.add_scalar('valid_loss', valid_loss, epoch) writer.add_scalar('valid_acc', valid_acc, epoch) print('Epoch: %d Train-Loss: %.6f | Train-Acc: %.3f%% | ' 'Validation-Loss: %.6f | Validation-Acc: %.3f%% | ' 'Max Validation-Acc: %.3f%% (epoch: %d)' % (epoch, mean_train_loss, train_acc, valid_loss, valid_acc, max_valid_acc, max_valid_acc_epoch)) # Save checkpoint. if save_weights: model_dict = { 'classifier': classifier.state_dict(), 'optimizer': optimizer.state_dict(), 'train_loss': mean_train_loss, 'train_acc': train_acc, 'valid_loss': valid_loss, 'valid_acc': valid_acc, 'epoch': epoch, 'timestamp': datetime.now().strftime("%y/%m/%d %H:%M:%S"), } weights_path = '{}.{:d}'.format(train_params.weights_path, epoch) print('Saving weights to {}'.format(weights_path)) torch.save(model_dict, weights_path) if params.enable_test: test_set = FontsDataset('test_data.npz') test_dataloader = torch.utils.data.DataLoader(test_set, batch_size=24, num_workers=4) else: test_dataloader = valid_dataloader start_t = time.time() _, test_acc, n_test = evaluate(classifier, test_dataloader, criterion, train_params.vis, device) end_t = time.time() test_time = end_t - start_t fps = n_test / test_time print('test accuracy: {:.4f}%'.format(test_acc)) print( 'test time: {:.4f} sec. with {:d} images ({:.4f} images / sec)'.format( test_time, n_test, fps))
def main(): global _pause, _quit params = VisParams() paramparse.process(params) # _args = [k for k in sys.argv[1:] if not k.startswith('vis.')] # vis_args = ['--{}'.format(k.replace('vis.', '')) for k in sys.argv[1:] if k.startswith('vis.')] # processArguments(_args, params) # params = _params seq_paths = params.seq_paths root_dir = params.root_dir csv_paths = params.csv_paths csv_root_dir = params.csv_root_dir class_names_path = params.class_names_path data_type = params.data_type n_frames = params.n_frames seq_prefix = params.seq_prefix n_vis = params.n_vis vis_size = params.vis_size enable_masks = params.enable_masks show_img = params.show_img save = params.save save_fmt = params.save_fmt save_dir = params.save_dir labels = params.labels grid_size = params.grid_size only_boxes = params.only_boxes crop_size = params.crop_size if crop_size: crop_size = tuple([int(x) for x in crop_size.split('x')]) print('Cropping a region of size {}x{} around the box'.format( *crop_size)) else: crop_size = () if grid_size: grid_size = [int(k) for k in grid_size.split('x')] print('Using a grid size of {}x{}'.format(*grid_size)) else: grid_size = None # params = Namespace(**params) if vis_size: vis_size = [int(x) for x in vis_size.split('x')] # get parameters # _params = ServerParams() # _params.processArguments() # print('vis_args: ', _params.vis.__dict__) # processArguments2(_params, vis_args) # print('_params: ', _params) # setup logger logging_fmt = '%(levelname)s::%(module)s::%(funcName)s::%(lineno)s : %(message)s' logging_level = logging.INFO # logging_level = logging.DEBUG # logging_level = PROFILE_LEVEL_NUM logging.basicConfig(level=logging_level, format=logging_fmt) _logger = logging.getLogger() _logger.setLevel(logging.INFO) if seq_paths: if os.path.isfile(seq_paths): seq_paths = [ x.strip() for x in open(seq_paths).readlines() if x.strip() ] else: seq_paths = seq_paths.split(',') if root_dir: seq_paths = [os.path.join(root_dir, name) for name in seq_paths] elif root_dir: seq_paths = [ os.path.join(root_dir, name) for name in os.listdir(root_dir) if os.path.isdir(os.path.join(root_dir, name)) ] seq_paths.sort(key=sortKey) else: raise IOError('Either seq_paths or root_dir must be provided') if csv_paths: if os.path.isfile(csv_paths): csv_paths = [ x.strip() for x in open(csv_paths).readlines() if x.strip() ] else: csv_paths = csv_paths.split(',') if csv_root_dir: csv_paths = [ os.path.join(csv_root_dir, name) for name in csv_paths ] elif csv_root_dir: csv_paths = [ os.path.join(csv_root_dir, name) for name in os.listdir(csv_root_dir) if os.path.isfile(os.path.join(csv_root_dir, name)) and name.endswith('.csv') ] csv_paths.sort(key=sortKey) else: csv_paths = [ os.path.join(seq_path, data_type + '.csv') for seq_path in seq_paths ] seq_path_ids = [] if seq_prefix: seq_path_ids = [ _id for _id, seq_path in enumerate(seq_paths) if os.path.basename(seq_path).startswith(seq_prefix) ] seq_paths = [seq_paths[_id] for _id in seq_path_ids] csv_paths = [csv_paths[_id] for _id in seq_path_ids] n_seq, n_csv = len(seq_paths), len(csv_paths) if n_seq != n_csv: raise IOError( 'Mismatch between image {} and annotation {} lengths'.format( n_seq, n_csv)) class_names = open(class_names_path, 'r').readlines() class_dict = {x.strip(): i for (i, x) in enumerate(class_names)} print('class_dict: ', class_dict) print('labels: ', labels) if n_vis > 0: if save: save_fname = '{:s}_{:s}.{:s}'.format(save_dir, getDateTime(), save_fmt) save_path = os.path.join('log', save_fname) writer = ImageWriter(save_path, _logger) _logger.info('Saving {:s} image sequence to {:s}'.format( save_fmt, save_path)) if n_seq % n_vis != 0: raise AssertionError('n_seq: {} not multiple of n_vis: {}'.format( n_seq, n_vis)) n_groups = int(n_seq / n_vis) seq_id = 0 label = '' for i in range(n_groups): vis_gen = [] for j in range(n_vis): if labels: label = labels[j] vis_gen.append( visualize(params.vis, _logger, seq_paths[seq_id], csv_paths[seq_id], class_dict, n_frames=n_frames, generator_mode=1, enable_masks=enable_masks, label=label, only_boxes=only_boxes, crop_size=crop_size)) seq_id += 1 for imgs in zip(*vis_gen): # img_stacked = np.hstack(imgs) stack_params = {'grid_size': grid_size, 'preserve_order': 1} if crop_size: stack_params['annotations'] = labels img_stacked = stackImages_ptf(imgs, **stack_params) img_stacked = cv2.cvtColor(img_stacked, cv2.COLOR_RGB2BGR) if vis_size: img_stacked = resizeAR(img_stacked, vis_size[0], vis_size[1]) if save: writer.write(img_stacked) if show_img: cv2.imshow('img_stacked', img_stacked) key = cv2.waitKey(1 - _pause) % 256 if key == 27: break elif key == ord('q'): _quit = 1 break elif key == 32: _pause = 1 - _pause if _quit: break if save: writer.release() else: for i in range(n_seq): visualize(params.vis, _logger, seq_paths[i], csv_paths[i], class_dict, n_frames=n_frames, enable_masks=enable_masks) if _quit: break
def main(): params = Params() paramparse.process(params) in_txt = copy_from_clipboard() if in_txt is None: lines = [] else: lines = in_txt.split('\n') lines = [line.strip() for line in lines if line.strip()] if lines: is_path = all( line.startswith('"') and line.endswith('"') for line in lines) if is_path: stripped_lines = [line.strip('"') for line in lines] else: stripped_lines = lines[:] try: is_ogg = all(line.endswith('.ogg') for line in stripped_lines) is_folder = all(os.path.isdir(line) for line in stripped_lines) except BaseException as e: print('exception during ogg / folder check : {}'.format(e)) is_ogg = 0 is_folder = 0 print('is_ogg: {}'.format(is_ogg)) print('stripped_lines: {}'.format(stripped_lines)) print('lines: {}'.format(lines)) # # input('press any key') if is_ogg: process_ogg(stripped_lines, lines, params.category, is_path, params.cmd, pause_for_input=1) return elif is_folder: stripped_lines.sort() for folder in stripped_lines: ogg_paths = [ '{}'.format(os.path.join(folder, k)) for k in os.listdir(folder) if k.endswith('.ogg') ] ogg_lines = ['"{}"'.format(k) for k in ogg_paths] process_ogg(ogg_paths, ogg_lines, params.category, is_path, params.cmd, pause_for_input=0) return else: try: out_txt = process(in_txt) except: pass else: copy_to_clipboard(out_txt, print_txt=1) time.sleep(0.5) return if params.ffs.enable: for _ffs_file in params.ffs.files: ffs_path = os.path.join(params.ffs.root, _ffs_file + '.' + params.ffs.ext) ffs_cmd = '{} "{}"'.format(params.ffs.exe, ffs_path) print(ffs_cmd) os.system(ffs_cmd) if params.txt_path: assert os.path.isdir(params.txt_path), "invalid text path: {}".format( params.txt_path) if params.recursive: files_gen = [[ linux_path(dirpath, f) for f in filenames if f.endswith('.txt') and f.startswith('Timing') ] for (dirpath, dirnames, filenames) in os.walk(params.txt_path, followlinks=True)] files = [item for sublist in files_gen for item in sublist] else: files = os.listdir(params.txt_path) files = [ linux_path(params.txt_path, k) for k in files if k and k.endswith('.txt') ] txt_proc_list_path = linux_path(params.txt_path, params.txt_proc_list) if os.path.isfile(txt_proc_list_path): processed_files = open(txt_proc_list_path, 'r').readlines() processed_files = [ k.strip().split('\t')[1] for k in processed_files if k.strip() ] files = [k for k in files if k not in processed_files] files.sort(key=os.path.getmtime) n_files = len(files) if n_files > 0: _ = input('\nfound {} new files:\n{}\nPress any key to continue\n'. format(n_files, files)) else: _ = input('\nfound no new files. Press any key to exit\n') for file_id, file in enumerate(files[::-1]): if file_id > 0: _ = input('\nDone {} / {}. Press any key to continue\n'.format( file_id, n_files)) print('reading file {} / {}: {}'.format(file_id + 1, n_files, file)) # file = dst_file in_txt = open(file, 'r').read() out_txt = process(in_txt, verbose=0) print(out_txt) copy_to_clipboard(out_txt) time.sleep(0.5) out_txt_lines = [k for k in out_txt.split('\n') if k] n_out_txt_lines = len(out_txt_lines) # dst_file = file.replace('.txt', '.log') # shutil.move(file, dst_file) print('out_txt_lines: {}'.format(out_txt_lines)) print('n_out_txt_lines: {}'.format(n_out_txt_lines)) if n_out_txt_lines == 1: os.system("vscode {}".format(file)) with open(txt_proc_list_path, 'r+') as f: content = f.read() f.seek(0, 0) timestamp_str = datetime.now().strftime( "%y%m%d %H:%M:%S.%f")[:-4] txt = '{}\t{}\n'.format(timestamp_str, file) f.write(txt + content) return # time.sleep(1) try: orig_x, orig_y = win32api.GetCursorPos() print('GetCursorPos x: {}'.format(orig_x)) print('GetCursorPos y: {}'.format(orig_y)) win32gui.EnumWindows(foreach_window, None) # for i in range(len(titles)): # print(titles[i]) target_title = [ k[1] for k in titles if all(title in k[1] for title in params.win_titles) ] # print('target_title: {}'.format(target_title)) if not target_title: raise IOError('Window with win_titles: {} not found'.format( params.win_titles)) target_title = target_title[0] target_handle = win32gui.FindWindow(None, target_title) rect = win32gui.GetWindowRect(target_handle) x = int((rect[0] + rect[2]) / 2) y = int((rect[1] + rect[3]) / 2) # active_handle = win32gui.GetForegroundWindow() # target_title = win32gui.GetWindowText(active_handle) print('target_title: {}'.format(target_title)) print('rect: {}'.format(rect)) print('x: {}'.format(x)) print('y: {}'.format(y)) try: app = application.Application().connect(title=target_title, found_index=0) except BaseException as e: print('Failed to connect to app for window {}: {}'.format( target_title, e)) exit(0) try: app_win = app.window(title=target_title) except BaseException as e: print('Failed to access app window for {}: {}'.format( target_title, e)) exit(0) app_win.type_keys("^a") app_win.type_keys("^c") mouse.move(coords=(x, y)) mouse.click(button='left', coords=(x, y)) mouse.click(button='left', coords=(x, y)) mouse.move(coords=(orig_x, orig_y)) except BaseException as e: print('BaseException: {}'.format(e)) in_txt = copy_from_clipboard() out_txt = process(in_txt) # with open(out_fname, 'w') as out_fid: # out_fid.write(out_txt) copy_to_clipboard(out_txt, print_txt=1)
def main(): params = Params() paramparse.process(params) _convert_dataset(params)
def main(): params = A9_Params() # optional command line argument parsing try: import paramparse except ImportError: pass else: paramparse.process(params) # init device if params.use_cuda and torch.cuda.is_available(): device = torch.device("cuda") print('Training on GPU: {}'.format(torch.cuda.get_device_name(0))) else: device = torch.device("cpu") print('Training on CPU') # load dataset if params.dataset == 0: print('Using MNIST dataset') transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)), ]) train_set = datasets.MNIST('data', train=True, download=True, transform=transform) test_set = datasets.MNIST('data', train=False, download=True, transform=transform) valid_set = datasets.MNIST('data', train=True, download=True, transform=transform) train_params = params.mnist elif params.dataset == 1: print('Using Fashion MNIST dataset') transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,)), ]) train_set = datasets.FashionMNIST('data', train=True, download=True, transform=transform) test_set = datasets.FashionMNIST('data', train=False, download=True, transform=transform) valid_set = datasets.FashionMNIST('data', train=True, download=True, transform=transform) train_params = params.fmnist else: raise IOError('Invalid db_type: {}'.format(params.dataset)) num_train = len(train_set) indices = list(range(num_train)) split = int(np.floor(params.train_split * num_train)) train_idx, valid_idx = indices[:split], indices[split:] train_set = PartiallyLabeled(train_set, train_idx, labeled_percent=params.labeled_split) print('Training samples: {}\n' 'Validation samples: {}\n' 'Labeled training samples: {}' ''.format( len(train_idx), len(valid_idx), train_set.n_labeled_data )) train_sampler = SubsetRandomSampler(train_idx) valid_sampler = SequentialSampler(valid_idx) train_dataloader = torch.utils.data.DataLoader(train_set, batch_size=train_params.batch_size, sampler=train_sampler, num_workers=4) valid_dataloader = torch.utils.data.DataLoader(valid_set, batch_size=24, sampler=valid_sampler, num_workers=4) test_dataloader = torch.utils.data.DataLoader(test_set, batch_size=10, shuffle=False, num_workers=4) # create modules encoder = Encoder(device).to(device) decoder = Decoder(device).to(device) classifier = Classifier(device).to(device) assert isinstance(encoder, nn.Module), 'encoder must be an instance of nn.Module' assert isinstance(decoder, nn.Module), 'decoder must be an instance of nn.Module' assert isinstance(classifier, nn.Module), 'classifier must be an instance of nn.Module' modules = nn.ModuleList((encoder, decoder, classifier)) # init weights encoder.init_weights() decoder.init_weights(encoder.get_weights()) classifier.init_weights() # create losses criterion_rec = torch.nn.MSELoss().to(device) criterion_cls = torch.nn.CrossEntropyLoss().to(device) parameters = list(modules.parameters()) if train_params.c0 == 0: composite_loss = CompositeLoss(device) composite_loss.init_weights() assert isinstance(composite_loss, nn.Module), 'composite_loss must be an instance of nn.Module' parameters += list(composite_loss.parameters()) else: def composite_loss(x, y): return x + train_params.c0 * y # create optimizer if train_params.optim_type == 0: optimizer = torch.optim.SGD(parameters, lr=train_params.lr, momentum=train_params.momentum, weight_decay=train_params.weight_decay) elif train_params.optim_type == 1: optimizer = torch.optim.Adam(parameters, lr=train_params.lr, weight_decay=train_params.weight_decay) else: raise IOError('Invalid optim_type: {}'.format(train_params.optim_type)) weights_dir = os.path.dirname(train_params.weights_path) weights_name = os.path.basename(train_params.weights_path) if not os.path.isdir(weights_dir): os.makedirs(weights_dir) start_epoch = 0 max_valid_acc_epoch = 0 max_valid_acc = 0 max_train_acc = 0 min_valid_loss = np.inf min_train_loss = np.inf # load weights if train_params.load_weights: matching_ckpts = [k for k in os.listdir(weights_dir) if os.path.isfile(os.path.join(weights_dir, k)) and k.startswith(weights_name)] if not matching_ckpts: msg = 'No checkpoints found matching {} in {}'.format(weights_name, weights_dir) if train_params.load_weights == 1: raise IOError(msg) print(msg) else: matching_ckpts.sort(key=lambda x: [int(c) if c.isdigit() else c for c in re.split(r'(\d+)', x)]) weights_path = os.path.join(weights_dir, matching_ckpts[-1]) chkpt = torch.load(weights_path, map_location=device) # load checkpoint print('Loading weights from: {} with:\n' '\tepoch: {}\n' '\ttrain_loss: {}\n' '\ttrain_acc: {}\n' '\tvalid_loss: {}\n' '\tvalid_acc: {}\n' '\ttimestamp: {}\n'.format( weights_path, chkpt['epoch'], chkpt['train_loss'], chkpt['train_acc'], chkpt['valid_loss'], chkpt['valid_acc'], chkpt['timestamp'])) encoder.load_state_dict(chkpt['encoder']) decoder.load_state_dict(chkpt['decoder']) classifier.load_state_dict(chkpt['classifier']) optimizer.load_state_dict(chkpt['optimizer']) if train_params.c0 == 0 and 'composite_loss' in chkpt: composite_loss.load_state_dict(chkpt['composite_loss']) max_valid_acc = chkpt['valid_acc'] min_valid_loss = chkpt['valid_loss'] max_train_acc = chkpt['train_acc'] min_train_loss = chkpt['train_loss'] max_valid_acc_epoch = chkpt['epoch'] start_epoch = chkpt['epoch'] + 1 if train_params.load_weights != 1: # continue training for epoch in range(start_epoch, train_params.n_epochs): # Training modules.train() train_loss_rec = 0 train_loss_cls = 0 train_loss = 0 train_total = 0 train_correct = 0 batch_idx = 0 save_weights = 0 for batch_idx, (inputs, targets, is_labeled) in tqdm(enumerate(train_dataloader)): inputs = inputs.to(device) targets = targets.to(device) if not np.count_nonzero(is_labeled.detach().numpy()): continue is_labeled = is_labeled.squeeze().to(device) optimizer.zero_grad() outputs_enc = encoder(inputs) outputs_rec = decoder(outputs_enc) outputs_cls = classifier(outputs_enc) loss_rec = criterion_rec(outputs_rec, inputs) loss_cls = criterion_cls(outputs_cls[is_labeled, :], targets[is_labeled]) loss = composite_loss(loss_rec, loss_cls) mean_loss_rec = loss_rec.item() mean_loss_cls = loss_cls.item() train_loss_rec += mean_loss_rec train_loss_cls += mean_loss_cls loss.backward() optimizer.step() mean_loss = loss.item() train_loss += mean_loss _, predicted = outputs_cls.max(1) train_total += targets.size(0) train_correct += predicted.eq(targets).sum().item() mean_train_loss_rec = train_loss_rec / (batch_idx + 1) mean_train_loss_cls = train_loss_cls / (batch_idx + 1) mean_train_loss = train_loss / (batch_idx + 1) train_acc = 100. * train_correct / train_total valid_loss, valid_acc, valid_psnr = eval( modules, valid_dataloader, (criterion_rec, criterion_cls), train_params.vis, device) if valid_acc > max_valid_acc: max_valid_acc = valid_acc max_valid_acc_epoch = epoch if train_params.save_criterion == 0: save_weights = 1 if valid_loss < min_valid_loss: min_valid_loss = valid_loss if train_params.save_criterion == 1: save_weights = 1 if train_acc > max_train_acc: max_train_acc = train_acc if train_params.save_criterion == 2: save_weights = 1 if train_loss < min_train_loss: min_train_loss = train_loss if train_params.save_criterion == 3: save_weights = 1 print( 'Epoch: %d Train-Loss: %.6f (rec: %.6f, cls: %.6f) | Train-Acc: %.3f%% | ' 'Validation-Loss: %.6f | Validation-Acc: %.3f%% | Validation-PSNR: %.3f | ' 'Max Validation-Acc: %.3f%% (epoch: %d)' % ( epoch, mean_train_loss, mean_train_loss_rec, mean_train_loss_cls, train_acc, valid_loss, valid_acc, valid_psnr, max_valid_acc, max_valid_acc_epoch)) # Save checkpoint. if save_weights: model_dict = { 'encoder': encoder.state_dict(), 'decoder': decoder.state_dict(), 'classifier': classifier.state_dict(), 'optimizer': optimizer.state_dict(), 'train_loss': mean_train_loss, 'train_acc': train_acc, 'valid_loss': valid_loss, 'valid_acc': valid_acc, 'epoch': epoch, 'timestamp': datetime.now().strftime("%y/%m/%d %H:%M:%S"), } if train_params.c0 == 0: model_dict['composite_loss'] = composite_loss.state_dict() weights_path = '{}.{:d}'.format(train_params.weights_path, epoch) print('Saving weights to {}'.format(weights_path)) torch.save(model_dict, weights_path) print('Testing...') start_t = time.time() test_loss, test_acc, test_psnr = eval( modules, test_dataloader, (criterion_rec, criterion_cls), train_params.vis, device) end_t = time.time() test_time = end_t - start_t print('Test-Loss: %.6f | Test-Acc: %.3f%% | Test-PSNR: %.3f%% | Test-Time: %.3f sec' % ( test_loss, test_acc, test_psnr, test_time))