def main(checkpoint, input_files): os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() model_config, _, track_config = load_cfgs(checkpoint) track_config['log_level'] = 1 track_config["is_video"] = False g = tf.Graph() with g.as_default(): model = inference_wrapper.InferenceWrapper() restore_fn = model.build_graph_from_config(model_config, track_config, checkpoint) g.finalize() if not osp.isdir(track_config['log_dir']): logging.info('Creating inference directory: %s', track_config['log_dir']) mkdir_p(track_config['log_dir']) video_dirs = [] for file_pattern in input_files.split(","): video_dirs.extend(glob(file_pattern)) logging.info("Running tracking on %d videos matching %s", len(video_dirs), input_files) gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) with tf.Session(graph=g, config=sess_config) as sess: restore_fn(sess) tracker = Tracker(model, model_config=model_config, track_config=track_config) for video_dir in video_dirs: if not osp.isdir(video_dir): logging.warning( '{} is not a directory, skipping...'.format(video_dir)) continue video_name = osp.basename(video_dir) video_log_dir = osp.join(track_config['log_dir'], video_name) mkdir_p(video_log_dir) filenames = sort_nicely(glob(video_dir + '/img/*.jpg')) first_line = open(video_dir + '/groundtruth_rect.txt').readline() bb = [int(v) for v in first_line.strip().split(',')] # Rectangle: [x,y,width,height] init_bb = Rectangle(bb[0] - 1, bb[1] - 1, bb[2], bb[3]) # 0-index in python trajectory = tracker.track(sess, init_bb, filenames, video_log_dir) with open(osp.join(video_log_dir, 'track_rect.txt'), 'w') as f: for region in trajectory: rect_str = '{},{},{},{}\n'.format(region.x + 1, region.y + 1, region.width, region.height) f.write(rect_str)
def process_split(root_dir, save_dir, split, subdir='', ): data_dir = osp.join(root_dir, 'Data', 'VID', split) anno_dir = osp.join(root_dir, 'Annotations', 'VID', split, subdir) video_names = os.listdir(anno_dir) for idx, video in enumerate(video_names): print('{split}-{subdir} ({idx}/{total}): Processing {video}...'.format(split=split, subdir=subdir, idx=idx, total=len(video_names), video=video)) video_path = osp.join(anno_dir, video) xml_files = glob(osp.join(video_path, '*.xml')) for xml in xml_files: tree = ET.parse(xml) root = tree.getroot() folder = root.find('folder').text filename = root.find('filename').text # Read image img_file = osp.join(data_dir, folder, filename + '.JPEG') img = None # Get all object bounding boxes bboxs = [] for object in root.iter('object'): bbox = object.find('bndbox') xmax = float(bbox.find('xmax').text) xmin = float(bbox.find('xmin').text) ymax = float(bbox.find('ymax').text) ymin = float(bbox.find('ymin').text) width = xmax - xmin + 1 height = ymax - ymin + 1 bboxs.append([xmin, ymin, width, height]) for idx, object in enumerate(root.iter('object')): id = object.find('trackid').text class_name = object.find('name').text track_save_dir = get_track_save_directory(save_dir, 'train', subdir, video) mkdir_p(track_save_dir) savename = osp.join(track_save_dir, '{}.{:02d}.crop.x.jpg'.format(filename, int(id))) if osp.isfile(savename): continue # skip existing images if img is None: img = imread(img_file) # Get crop target_box = convert_bbox_format(Rectangle(*bboxs[idx]), 'center-based') crop, _ = get_crops(img, target_box, size_z=127, size_x=255, context_amount=0.5, ) imwrite(savename, crop, [int(cv2.IMWRITE_JPEG_QUALITY), 90])
def process_split(root_dir, save_dir, split, subdir='', ): data_dir = osp.join(root_dir, 'Data', 'VID', split) anno_dir = osp.join(root_dir, 'Annotations', 'VID', split, subdir) video_names = os.listdir(anno_dir) for idx, video in enumerate(video_names): print('{split}-{subdir} ({idx}/{total}): Processing {video}...'.format(split=split, subdir=subdir, idx=idx, total=len(video_names), video=video)) video_path = osp.join(anno_dir, video) xml_files = glob(osp.join(video_path, '*.xml')) for xml in xml_files: tree = ET.parse(xml) root = tree.getroot() folder = root.find('folder').text filename = root.find('filename').text # Read image img_file = osp.join(data_dir, folder, filename + '.JPEG') img = None # Get all object bounding boxes bboxs = [] for object in root.iter('object'): bbox = object.find('bndbox') xmax = float(bbox.find('xmax').text) xmin = float(bbox.find('xmin').text) ymax = float(bbox.find('ymax').text) ymin = float(bbox.find('ymin').text) width = xmax - xmin + 1 height = ymax - ymin + 1 bboxs.append([xmin, ymin, width, height]) for idx, object in enumerate(root.iter('object')): id = object.find('trackid').text class_name = object.find('name').text track_save_dir = get_track_save_directory(save_dir, 'train', subdir, video) mkdir_p(track_save_dir) savename = osp.join(track_save_dir, '{}.{:02d}.crop.x.jpg'.format(filename, int(id))) if osp.isfile(savename): continue # skip existing images if img is None: img = imread(img_file) # Get crop target_box = convert_bbox_format(Rectangle(*bboxs[idx]), 'center-based') crop, _ = get_crops(img, target_box, size_z=127, size_x=255, context_amount=0.01) imwrite(savename, crop, [int(cv2.IMWRITE_JPEG_QUALITY), 90])
def main(checkpoint, input_files): os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() model_config, _, track_config = load_cfgs(checkpoint) track_config['log_level'] = 1 g = tf.Graph() with g.as_default(): model = inference_wrapper.InferenceWrapper() restore_fn = model.build_graph_from_config(model_config, track_config, checkpoint) g.finalize() if not osp.isdir(track_config['log_dir']): logging.info('Creating inference directory: %s', track_config['log_dir']) mkdir_p(track_config['log_dir']) video_dirs = [] for file_pattern in input_files.split(","): video_dirs.extend(glob(file_pattern)) logging.info("Running tracking on %d videos matching %s", len(video_dirs), input_files) gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) with tf.Session(graph=g, config=sess_config) as sess: restore_fn(sess) tracker = Tracker(model, model_config=model_config, track_config=track_config) for video_dir in video_dirs: if not osp.isdir(video_dir): logging.warning('{} is not a directory, skipping...'.format(video_dir)) continue video_name = osp.basename(video_dir) video_log_dir = osp.join(track_config['log_dir'], video_name) mkdir_p(video_log_dir) filenames = sort_nicely(glob(video_dir + '/img/*.jpg')) first_line = open(video_dir + '/groundtruth_rect.txt').readline() bb = [int(v) for v in first_line.strip().split(',')] init_bb = Rectangle(bb[0] - 1, bb[1] - 1, bb[2], bb[3]) # 0-index in python trajectory = tracker.track(sess, init_bb, filenames, video_log_dir) with open(osp.join(video_log_dir, 'track_rect.txt'), 'w') as f: for region in trajectory: rect_str = '{},{},{},{}\n'.format(region.x + 1, region.y + 1, region.width, region.height) f.write(rect_str)
def main(): exp_dir = TRAIN_CONFIG['exp_dir'] if not os.path.exists(exp_dir): mkdir_p(exp_dir) #if len(sys.argv)==2 and sys.argv[1] != '--resume': # assert False, 'Experiment directory {} exists, prohibit overwritting...\n\t**Use python3 train.py --resume to force training...'.format(exp_dir) if os.path.exists(TRAIN_CONFIG['logfile'] ) and TRAIN_CONFIG['resume_checkpoint'] is None: os.remove(TRAIN_CONFIG['logfile']) logger = setup_logger(logfile=TRAIN_CONFIG['logfile']) os.system('cp {} {}'.format(CONF_FN, osp.join(exp_dir, CONF_FN.split('/')[-1]))) trainer = Trainer(logger) trainer.train()
def process_split(root_dir, save_dir, split): data_dir = osp.join(root_dir, split) video_names = os.listdir(data_dir) video_names = [vn for vn in video_names if '.txt' not in vn] for idx, video in enumerate(video_names): print('{split} ({idx}/{total}): Processing {video}...'.format(split=split, idx=idx, total=len(video_names), video=video)) video_path = osp.join(data_dir, video) jpg_files = glob(osp.join(video_path, '*.jpg')) with open(osp.join(video_path, 'groundtruth.txt')) as f: ann_content = f.readlines() for jpg in jpg_files: # Read image img_file = jpg.split('/')[-1] img = None # Get all object bounding boxes jpgidx = img_file.split('.')[0] jpgidx = int(jpgidx) - 1 ann = ann_content[jpgidx] ann = ann.strip() bbox = ann.split(',') bbox = [int(float(bb)) for bb in bbox] # [xmin, ymin, w, h] track_save_dir = osp.join(save_dir, split, video) mkdir_p(track_save_dir) savename = osp.join(track_save_dir, '{}.crop.x.jpg'.format(img_file)) if osp.isfile(savename): try: im = Image.open(savename) continue # skip existing images except IOError: os.remove(savename) if img is None: img = imread(jpg) # Get crop target_box = convert_bbox_format(Rectangle(*bbox), 'center-based') crop, _ = get_crops(img, target_box, size_z=127, size_x=255, context_amount=0.5) imwrite(savename, crop, [int(cv2.IMWRITE_JPEG_QUALITY), 90])
def __init__( self, debug=0, checkpoint='Logs/SiamFC/track_model_checkpoints/SiamFC-3s-color-pretrained' ): os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() # run only on cpu # os.environ['CUDA_VISIBLE_DEVICES'] = '-1' model_config, _, track_config = load_cfgs(checkpoint) track_config['log_level'] = debug g = tf.Graph() with g.as_default(): model = inference_wrapper.InferenceWrapper() restore_fn = model.build_graph_from_config(model_config, track_config, checkpoint) g.finalize() if not osp.isdir(track_config['log_dir']): logging.info('Creating inference directory: %s', track_config['log_dir']) mkdir_p(track_config['log_dir']) gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) sess = tf.Session(graph=g, config=sess_config) # sess.run(tf.global_variables_initializer()) restore_fn(sess) tracker = Tracker(model, model_config=model_config, track_config=track_config) video_name = "demo" video_log_dir = osp.join(track_config['log_dir'], video_name) rmdir(video_log_dir) mkdir_p(video_log_dir) self.tracker = tracker self.sess = sess self.video_log_dir = video_log_dir self.graph = g
def main(model_config, train_config, track_config): os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() # Create training directory which will be used to save: configurations, model files, TensorBoard logs train_dir = train_config['train_dir'] if not osp.isdir(train_dir): logging.info('Creating training directory: %s', train_dir) mkdir_p(train_dir) g = tf.Graph() with g.as_default(): # Set fixed seed for reproducible experiments random.seed(train_config['seed']) np.random.seed(train_config['seed']) tf.set_random_seed(train_config['seed']) # Build the training and validation model model = siamese_model.SiameseModel(model_config, train_config, mode='train') model.build() model_va = siamese_model.SiameseModel(model_config, train_config, mode='validation') model_va.build(reuse=True) # Save configurations for future reference save_cfgs(train_dir, model_config, train_config, track_config) learning_rate = _configure_learning_rate(train_config, model.global_step) optimizer = _configure_optimizer(train_config, learning_rate) tf.summary.scalar('learning_rate', learning_rate) # Set up the training ops opt_op = tf.contrib.layers.optimize_loss( loss=model.total_loss, global_step=model.global_step, learning_rate=learning_rate, optimizer=optimizer, clip_gradients=train_config['clip_gradients'], learning_rate_decay_fn=None, summaries=['learning_rate']) with tf.control_dependencies([opt_op]): train_op = tf.no_op(name='train') saver = tf.train.Saver(tf.global_variables(), max_to_keep=train_config['max_checkpoints_to_keep']) summary_writer = tf.summary.FileWriter(train_dir, g) summary_op = tf.summary.merge_all() global_variables_init_op = tf.global_variables_initializer() local_variables_init_op = tf.local_variables_initializer() g.finalize() # Finalize graph to avoid adding ops by mistake # Dynamically allocate GPU memory gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) sess = tf.Session(config=sess_config) model_path = tf.train.latest_checkpoint(train_config['train_dir']) if not model_path: sess.run(global_variables_init_op) sess.run(local_variables_init_op) start_step = 0 if model_config['embed_config']['embedding_checkpoint_file']: model.init_fn(sess) else: logging.info('Restore from last checkpoint: {}'.format(model_path)) sess.run(local_variables_init_op) saver.restore(sess, model_path) start_step = tf.train.global_step(sess, model.global_step.name) + 1 # Training loop data_config = train_config['train_data_config'] total_steps = int(data_config['epoch'] * data_config['num_examples_per_epoch'] / data_config['batch_size']) logging.info('Train for {} steps'.format(total_steps)) for step in range(start_step, total_steps): start_time = time.time() _, loss, batch_loss = sess.run([train_op, model.total_loss, model.batch_loss]) duration = time.time() - start_time if step % 10 == 0: examples_per_sec = data_config['batch_size'] / float(duration) time_remain = data_config['batch_size'] * (total_steps - step) / examples_per_sec m, s = divmod(time_remain, 60) h, m = divmod(m, 60) format_str = ('%s: step %d, total loss = %.2f, batch loss = %.2f (%.1f examples/sec; %.3f ' 'sec/batch; %dh:%02dm:%02ds remains)') logging.info(format_str % (datetime.now(), step, loss, batch_loss, examples_per_sec, duration, h, m, s)) if step % 100 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) if step % train_config['save_model_every_n_step'] == 0 or (step + 1) == total_steps: checkpoint_path = osp.join(train_config['train_dir'], 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step)
def main(model_config, train_config, track_config): # GPU Config gpu_list = train_config['train_data_config'].get('gpu_ids', '0') num_gpus = len(gpu_list.split(',')) if num_gpus > 1: os.environ['CUDA_VISIBLE_DEVICES'] = gpu_list else: os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() # Create training directory which will be used to save: configurations, model files, TensorBoard logs train_dir = train_config['train_dir'] if not osp.isdir(train_dir): logging.info('Creating training directory: %s', train_dir) mkdir_p(train_dir) g = tf.Graph() with g.as_default(): # Set fixed seed for reproducible experiments random.seed(train_config['seed']) np.random.seed(train_config['seed']) tf.set_random_seed(train_config['seed']) #Build global step with tf.name_scope('train/'): global_step = tf.Variable(initial_value=0, name='global_step', trainable=False, collections=[ tf.GraphKeys.GLOBAL_STEP, tf.GraphKeys.GLOBAL_VARIABLES ]) Model = get_model(model_config['Model']) # build training dataloader and validation dataloader #---train train_dataloader = DataLoader(train_config['train_data_config'], is_training=True) train_dataloader.build() train_inputs = train_dataloader.get_one_batch() #---validation val_dataloader = DataLoader(train_config['validation_data_config'], is_training=False) val_dataloader.build() val_inputs = val_dataloader.get_one_batch() # Save configurations for future reference save_cfgs(train_dir, model_config, train_config, track_config) if train_config['lr_config'].get('lr_warmup', False): warmup_epoch_num = 10 init_lr_ratio = 0.8 warmup_steps = warmup_epoch_num * int( train_config['train_data_config']['num_examples_per_epoch'] ) // train_config['train_data_config']['batch_size'] inc_per_step = ( 1 - init_lr_ratio ) * train_config['lr_config']['initial_lr'] / warmup_steps warmup_lr = train_config['lr_config'][ 'initial_lr'] * init_lr_ratio + inc_per_step * tf.to_float( global_step) learning_rate = tf.cond( tf.less(global_step, warmup_steps), lambda: tf.identity(warmup_lr), lambda: _configure_learning_rate(train_config, global_step - warmup_steps)) else: learning_rate = _configure_learning_rate(train_config, global_step) optimizer = _configure_optimizer(train_config, learning_rate) tf.summary.scalar('learning_rate', learning_rate) # Set up the training ops examplars, instances, gt_examplar_boxes, gt_instance_boxes = tf.split(train_inputs[0],num_gpus), \ tf.split(train_inputs[1],num_gpus), \ tf.split(train_inputs[2],num_gpus), \ tf.split(train_inputs[3],num_gpus) if train_config['train_data_config'].get('time_decay', False): time_intervals = tf.split(train_inputs[4], num_gpus) tower_grads = [] with tf.variable_scope(tf.get_variable_scope()): for i in range(num_gpus): with tf.device('/gpu:%d' % i): if train_config['train_data_config'].get( 'time_decay', False): inputs = [ examplars[i], instances[i], gt_examplar_boxes[i], gt_instance_boxes[i], time_intervals[i] ] else: inputs = [ examplars[i], instances[i], gt_examplar_boxes[i], gt_instance_boxes[i] ] model = tower_model(Model, inputs, model_config, train_config, mode='train') # Reuse variables for the next tower. tf.get_variable_scope().reuse_variables() grads = optimizer.compute_gradients(model.total_loss) tower_grads.append(grads) grads = average_gradients(tower_grads) #Clip gradient gradients, tvars = zip(*grads) clip_gradients, _ = tf.clip_by_global_norm( gradients, train_config['clip_gradients']) train_op = optimizer.apply_gradients(zip(clip_gradients, tvars), global_step=global_step) #Build validation model with tf.device('/gpu:0'): model_va = Model(model_config, train_config, mode='validation', inputs=val_inputs) model_va.build(reuse=True) #Save Model setup saver = tf.train.Saver( tf.global_variables(), max_to_keep=train_config['max_checkpoints_to_keep']) summary_writer = tf.summary.FileWriter(train_dir, g) summary_op = tf.summary.merge_all() global_variables_init_op = tf.global_variables_initializer() local_variables_init_op = tf.local_variables_initializer() # Dynamically allocate GPU memory gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options, allow_soft_placement=True) #inter_op_parallelism_threads = 16, intra_op_parallelism_threads = 16, log_device_placement=True) ######Debug timeline if Debug: from tensorflow.python.client import timeline run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() ######Debug timeline sess = tf.Session(config=sess_config) model_path = tf.train.latest_checkpoint(train_config['train_dir']) if not model_path: sess.run(global_variables_init_op) sess.run(local_variables_init_op) start_step = 0 if model_config['embed_config']['embedding_checkpoint_file']: model.init_fn(sess) elif model_config['finetuned_checkpoint_file']: finetuned_checkpoint_file = tf.train.latest_checkpoint( model_config['finetuned_checkpoint_file']) logging.info('Restore from last checkpoint: {}'.format( finetuned_checkpoint_file)) sess.run(local_variables_init_op) sess.run(global_variables_init_op) restore_op = tf.contrib.slim.assign_from_checkpoint_fn( finetuned_checkpoint_file, tf.global_variables(), ignore_missing_vars=True) restore_op(sess) #reset global step saved in checkpoint global_step_reset_op = global_step.assign(0) sess.run(global_step_reset_op) else: logging.info('Restore from last checkpoint: {}'.format(model_path)) sess.run(local_variables_init_op) sess.run(global_variables_init_op) #saver.restore(sess, model_path) restore_op = tf.contrib.slim.assign_from_checkpoint_fn( model_path, tf.global_variables(), ignore_missing_vars=True) restore_op(sess) start_step = tf.train.global_step(sess, global_step.name) + 1 print_trainable(sess) #help function, can be disenable g.finalize() # Finalize graph to avoid adding ops by mistake # Training loop data_config = train_config['train_data_config'] total_steps = int(data_config['epoch'] * data_config['num_examples_per_epoch'] / data_config['batch_size']) logging.info('Train for {} steps'.format(total_steps)) for step in range(start_step, total_steps): try: start_time = time.time() if Debug: _, loss, batch_loss, current_lr = sess.run( [ train_op, model.total_loss, model.batch_loss, learning_rate ], run_metadata=run_metadata, options=run_options) t1 = timeline.Timeline(run_metadata.step_stats) ctf = t1.generate_chrome_trace_format() with open('timeline.json', 'w') as f: f.write(ctf) else: _, loss, batch_loss, current_lr = sess.run([ train_op, model.total_loss, model.batch_loss, learning_rate ]) duration = time.time() - start_time if step % 10 == 0: examples_per_sec = data_config['batch_size'] / float( duration) time_remain = data_config['batch_size'] * ( total_steps - step) / examples_per_sec current_epoch = ( step * data_config['batch_size'] ) // data_config['num_examples_per_epoch'] + 1 m, s = divmod(time_remain, 60) h, m = divmod(m, 60) format_str = ( '%s: epoch %d-step %d,lr = %f, total loss = %.3f, batch loss = %.3f (%.1f examples/sec; %.3f ' 'sec/batch; %dh:%02dm:%02ds remains)') logging.info( format_str % (datetime.now(), current_epoch, step, current_lr, loss, batch_loss, examples_per_sec, duration, h, m, s)) if step % 200 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) if step % train_config['save_model_every_n_step'] == 0 or ( step + 1) == total_steps: checkpoint_path = osp.join(train_config['train_dir'], 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except KeyboardInterrupt: checkpoint_path = osp.join(train_config['train_dir'], 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) print("save model.ckpt-%d" % (step)) break except: print(traceback.format_exc()) print("Error found in current step, continue")
def process_split(root_dir, save_dir, split): data_dir = osp.join(root_dir, split) video_names = os.listdir(data_dir) video_names = [vn for vn in video_names if '.txt' not in vn] for idx, video in enumerate(video_names): print('{split} ({idx}/{total}): Processing {video}...'.format( split=split, idx=idx, total=len(video_names), video=video)) video_path = osp.join(data_dir, video) jpg_files = glob(osp.join(video_path, '*.jpg')) with open(osp.join(video_path, 'groundtruth.txt')) as f: ann_content = f.readlines() track_save_dir = osp.join(save_dir, split, video) mkdir_p(track_save_dir) fw = open(osp.join(track_save_dir, 'groundtruth.txt'), 'w') copyfile(osp.join(video_path, 'absence.label'), osp.join(track_save_dir, 'absence.label')) copyfile(osp.join(video_path, 'cover.label'), osp.join(track_save_dir, 'cover.label')) copyfile(osp.join(video_path, 'cut_by_image.label'), osp.join(track_save_dir, 'cut_by_image.label')) copyfile(osp.join(video_path, 'meta_info.ini'), osp.join(track_save_dir, 'meta_info.ini')) for i, jpg in enumerate(jpg_files): # Read image img_file = jpg.split('/')[-1] img = None # Get all object bounding boxes jpgidx = img_file.split('.')[0] jpgidx = int(jpgidx) - 1 ann = ann_content[jpgidx] ann = ann.strip() bbox = ann.split(',') bbox = [int(float(bb)) for bb in bbox] # [xmin, ymin, w, h] ## bbox #### annk = ann_content[i] annk = annk.strip() bboxk = annk.split(',') bboxk = [int(float(bb)) for bb in bboxk] # [xmin, ymin, w, h] w = bboxk[2] h = bboxk[3] context_amount = 0.5 size_z = 127 size_x = 271 wc_z = w + context_amount * (w + h) hc_z = h + context_amount * (w + h) s_z = np.sqrt(wc_z * hc_z) scale_z = size_z / s_z d_search = (size_x - size_z) / 2 pad = d_search / scale_z s_x = s_z + 2 * pad wn = int(w * size_x / s_x) hn = int(h * size_x / s_x) #if wn < 1 or hn < 1: #if wn == 0: #wn = 1 #if hn == 0: #hn = 1 #ratio = wn / hn #if ratio > 1.: #newbb = [int(135-wn/2), int(135-hn/2), 85, int(85. / ratio)] #else: #newbb = [int(135-wn/2), int(135-hn/2), int(85. * ratio), 85] #else: #newbb = [int(135-wn/2), int(135-hn/2), wn, hn] if wn < 1: wn = 1 if hn < 1: hn = 1 newbb = [int(135 - wn / 2), int(135 - hn / 2), wn, hn] fw.write(','.join(str(e) + '.0000' for e in newbb) + '\n') ## bbox #### savename = osp.join(track_save_dir, '{}.jpg'.format(img_file)) if osp.isfile(savename): try: im = Image.open(savename) continue # skip existing images except IOError: os.remove(savename) if img is None: img = imread(jpg) # Get crop target_box = convert_bbox_format(Rectangle(*bbox), 'center-based') crop, _ = get_crops(img, target_box, size_z=127, size_x=271, context_amount=0.5) imwrite(savename, crop, [int(cv2.IMWRITE_JPEG_QUALITY), 90]) fw.close()
# def main(checkpoint, input_files): # ============================================================================= os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() model_config, _, track_config = load_cfgs(checkpoint) track_config['log_level'] = 1 g = tf.Graph() with g.as_default(): model = mbst_inference_wrapper.InferenceWrapper() restore_fn = model.build_graph_from_config(model_config, track_config, checkpoint) if not osp.isdir(track_config['log_dir']): logging.info('Creating inference directory: %s', track_config['log_dir']) mkdir_p(track_config['log_dir']) gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) ALL_ResList = [] with tf.Session(graph=g, config=sess_config) as sess: ## used for initializing alexnet parameters init_global = tf.global_variables_initializer() sess.run(init_global)
def download_or_skip(download_url, save_path): if not osp.exists(save_path): print('Downloading: {}'.format(download_url)) opener = urllib.request.URLopener() opener.retrieve(download_url, save_path) else: print('File {} exists, skip downloading.'.format(save_path)) if __name__ == '__main__': assets_dir = osp.join(ROOT_DIR, 'assets') # Make assets directory mkdir_p(assets_dir) # Download the pretrained color model download_base = 'https://www.robots.ox.ac.uk/~luca/stuff/siam-fc_nets/' model_name = '2016-08-17.net.mat' download_or_skip(download_base + model_name, osp.join(assets_dir, model_name)) # Download the pretrained gray model download_base = 'https://www.robots.ox.ac.uk/~luca/stuff/siam-fc_nets/' model_name = '2016-08-17_gray025.net.mat' download_or_skip(download_base + model_name, osp.join(assets_dir, model_name)) # Download one test sequence download_base = "http://cvlab.hanyang.ac.kr/tracker_benchmark/seq_new/" seq_name = 'KiteSurf.zip' download_or_skip(download_base + seq_name, osp.join(assets_dir, seq_name))
def main(_): # load model model_config, _, track_config = load_cfgs(CHECKPOINT) track_config["log_level"] = 0 track_config["is_video"] = True g = tf.Graph() with g.as_default(): model = inference_wrapper.InferenceWrapper() restore_fn = model.build_graph_from_config(model_config, track_config, CHECKPOINT) g.finalize() if not os.path.isdir(track_config['log_dir']): tf.logging.info('Creating inference directory: %s', track_config['log_dir']) mkdir_p(track_config['log_dir']) gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) with tf.Session(graph=g, config=sess_config) as sess: restore_fn(sess) tracker = Tracker(model, model_config=model_config, track_config=track_config) video_name = os.path.basename(FLAGS.video_path) video_log_dir = os.path.join(track_config["log_dir"], video_name) mkdir_p(video_log_dir) if str(FLAGS.video_path) in ["0", "1"]: # read from camera video_path = int(FLAGS.video_path) with_camera = True else: # read from video video_path = glob(os.path.join(FLAGS.video_path, "*.mp4"))[0] with_camera = False video_capture = cv2.VideoCapture(video_path) bb = [-1, -1, -1, -1] cv2.namedWindow("template") cv2.setMouseCallback("template", draw_init_box, bb) trajectory = [] f_count = 0 f_rate = 0 start_time = time.time() while True: # capture frame by frame ret_, frame = video_capture.read() if ret_ == False: continue f_width, f_height = [ int(a) for a in FLAGS.video_resolution.split("*") ] try: o_frame = cv2.resize(frame, (f_width, f_height), interpolation=cv2.INTER_CUBIC) except: break i_frame = cv2.cvtColor(o_frame, cv2.COLOR_BGR2RGB) # cv2.imwrite("test.jpg",o_frame) # pdb.set_trace() if f_count == 0: # initialize the tracker # wait for drawing init box while True: init_frame = o_frame.copy() cv2.imshow("template", init_frame) k = cv2.waitKey(0) if k == 32: # space cx = int((bb[0] + bb[2]) / 2) cy = int((bb[1] + bb[3]) / 2) w = int(bb[2] - bb[0]) h = int(bb[3] - bb[1]) # Rectangle: [x,y,width,height] init_bb = Rectangle(cx - 1, cy - 1, w, h) # 0-index in python draw_box(init_frame, init_bb, "exemplar") break first_box = convert_bbox_format(init_bb, "center-based") bbox_feed = [ first_box.y, first_box.x, first_box.height, first_box.width ] input_feed = [i_frame, bbox_feed] frame2crop_scale = tracker.siamese_model.initialize( sess, input_feed) # Storing target state original_target_height = first_box.height original_target_width = first_box.width search_center = np.array([ get_center(tracker.x_image_size), get_center(tracker.x_image_size) ]) current_target_state = TargetState( bbox=first_box, search_pos=search_center, scale_idx=int(get_center(tracker.num_scales))) # setup initialized params current_param = { "original_target_width": original_target_width, "original_target_height": original_target_height, "search_center": search_center, "current_target_state": current_target_state } bbox, current_param = tracker.track_frame(sess, i_frame, current_param, video_log_dir) # add overlays end_time = time.time() f_rate = int(1 / (end_time - start_time)) start_time = time.time() draw_box(o_frame, bbox) cv2.putText(o_frame, str(f_rate) + "fps", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), thickness=2, lineType=2) trajectory.append(bbox) f_count += 1 cv2.imshow("Real-time Ouput", o_frame) cv2.imshow("template", init_frame) # if f_count > 30: # cv2.imwrite("test.jpg",o_frame) # pdb.set_trace() if cv2.waitKey(1) & 0xFF == ord("q"): cv2.imwrite("./assets/instance.jpg", o_frame) cv2.imwrite("./assets/exemplar.jpg", init_frame) break video_capture.release() cv2.destroyAllWindows() # save track results # pdb.set_trace() with open(os.path.join(video_log_dir, "track_rect.txt"), "w") as f: for region in trajectory: rect_str = "{},{},{},{}\n".format(region.x + 1, region.y + 1, region.width, region.height) f.write(rect_str)
def main(checkpoint, input_files): os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() model_config, _, track_config = load_cfgs(checkpoint) track_config['log_level'] = 1 g = tf.Graph() with g.as_default(): model = inference_wrapper.InferenceWrapper() restore_fn = model.build_graph_from_config(model_config, track_config, checkpoint) g.finalize() if not osp.isdir(track_config['log_dir']): logging.info('Creating inference directory: %s', track_config['log_dir']) mkdir_p(track_config['log_dir']) video_dirs = [] for file_pattern in input_files.split(","): video_dirs.extend(glob(file_pattern)) logging.info("Running tracking on %d videos matching %s", len(video_dirs), input_files) gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) with tf.Session(graph=g, config=sess_config) as sess: restore_fn(sess) tracker = Tracker(model, model_config=model_config, track_config=track_config) for video_dir in video_dirs: if not osp.isdir(video_dir): logging.warning( '{} is not a directory, skipping...'.format(video_dir)) continue video_name = osp.basename(video_dir) video_log_dir = osp.join(track_config['log_dir'], video_name) mkdir_p(video_log_dir) filenames = sort_nicely( glob(video_dir + '/img/*.jpg') + glob(video_dir + '/img/*.png')) first_line = open(video_dir + '/groundtruth_rect.txt').readline() bb = [int(v) for v in first_line.strip().split(',')] init_bb = Rectangle(bb[0] - 1, bb[1] - 1, bb[2], bb[3]) # 0-index in python trajectory = tracker.track(sess, init_bb, filenames, video_log_dir) with open(osp.join(video_log_dir, 'track_rect.txt'), 'w') as f: for region in trajectory: rect_str = '{},{},{},{}\n'.format(region.x + 1, region.y + 1, region.width, region.height) f.write(rect_str) with open(osp.join(video_log_dir, 'bboxes.json'), 'r') as f: data = json.load(f) final_output = {} for i, fname in enumerate(data.keys()): img = np.array(Image.open(fname).convert('RGB')) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #print(img,img.shape) bboxes = data[fname] bboxes = list( map( lambda x: list( map(lambda y: float(y), x.strip().split(','))), bboxes)) arr = [] for x, y, w, h in bboxes: ymin, xmin, ymax, xmax = int(y), int(x), int(y + h), int(x + w) img = cv2.rectangle(img, (xmin, ymin), (xmax, ymax), (0, 255, 0, 255), 2) arr.append([ymin, xmin, ymax, xmax]) final_output[fname] = arr name = osp.basename(fname) name = osp.splitext(name)[0] W, H, _ = img.shape cv2.imshow("Pic", cv2.resize(img, (W // 2, H // 2))) cv2.waitKey(0) out_folder = osp.join(video_log_dir, "Outputs") mkdir_p(out_folder) cv2.imwrite(osp.join(out_folder, f"{name}_bbox.png"), img) with open(osp.join(out_folder, "output.json"), "w") as f: json.dump(final_output, f, indent=4) cv2.destroyAllWindows()
def main(model_config, train_config, track_config): os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() # Create training directory which will be used to save: configurations, model files, TensorBoard logs train_dir = train_config['train_dir'] if not osp.isdir(train_dir): logging.info('Creating training directory: %s', train_dir) mkdir_p(train_dir) if have_cfgs(train_dir): model_config, train_config, track_config = load_cfgs(train_dir) print("=================== load cfg ") else: save_cfgs(train_dir, model_config, train_config, track_config) print("=================== save default cfg, please modify files in {}".format(train_dir)) return g = tf.Graph() with g.as_default(): # Set fixed seed for reproducible experiments random.seed(train_config['seed']) np.random.seed(train_config['seed']) tf.set_random_seed(train_config['seed']) # Build the training and validation model model = siamese_model.SiameseModel(model_config, train_config, track_config, mode='train') model.build() model_va = siamese_model.SiameseModel(model_config, train_config, track_config, mode='validation') model_va.build(reuse=True) learning_rate = _configure_learning_rate(train_config, model.global_step) optimizer = _configure_optimizer(train_config, learning_rate) tf.summary.scalar('learning_rate', learning_rate) # general way for run train: https://qiita.com/horiem/items/00ec6488b23895cc4fe2 # tensorflow 2.1: https://www.tensorflow.org/tutorials/customization/custom_training_walkthrough # Set up the training ops opt_op = tensorflow.contrib.layers.optimize_loss( loss=model.total_loss, global_step=model.global_step, learning_rate=learning_rate, optimizer=optimizer, clip_gradients=train_config['clip_gradients'], learning_rate_decay_fn=None, summaries=['learning_rate']) with tf.control_dependencies([opt_op]): train_op = tf.no_op(name='train') saver = tf.train.Saver(tf.global_variables(), max_to_keep=train_config['max_checkpoints_to_keep']) summary_writer = tf.summary.FileWriter(train_dir, g) summary_op = tf.summary.merge_all() global_variables_init_op = tf.global_variables_initializer() local_variables_init_op = tf.local_variables_initializer() g.finalize() # Finalize graph to avoid adding ops by mistake # Dynamically allocate GPU memory gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) sess = tf.Session(config=sess_config) model_path = tf.train.latest_checkpoint(train_config['train_dir']) if not model_path: sess.run(global_variables_init_op) sess.run(local_variables_init_op) start_step = 0 if model_config['embed_config']['embedding_checkpoint_file']: model.init_fn(sess) else: logging.info('Restore from last checkpoint: {}'.format(model_path)) sess.run(local_variables_init_op) saver.restore(sess, model_path) start_step = tf.train.global_step(sess, model.global_step.name) + 1 # export if train_config["export"]: # still debugging ''' frozen_graph_def = tf.graph_util.convert_variables_to_constants(sess, tf.get_default_graph().as_graph_def(), ["train/detection/add"]) frozen_graph = tf.Graph() with frozen_graph.as_default(): tf.import_graph_def(frozen_graph_def) save_model_dir = osp.join(train_config['train_dir'], 'models') tf.train.write_graph(frozen_graph_def, save_model_dir, 'quantized_frozen_graph.pb', as_text=False) tf.train.write_graph(frozen_graph_def, save_model_dir, 'quantized_frozen_graph.pbtxt', as_text=True) output_op = sess.graph.get_tensor_by_name("validation/detection/add:0") input1_op = sess.graph.get_tensor_by_name("validation/template_image:0") input2_op = sess.graph.get_tensor_by_name("validation/input_image:0") converter = tf.lite.TFLiteConverter.from_session(sess, [input1_op, input2_op], [output_op]) converter.inference_type = tf.lite.constants.QUANTIZED_UINT8 input_arrays = converter.get_input_arrays() converter.quantized_input_stats = {input_arrays[0] : (0., 1.), input_arrays[1] : (0., 1.)} # mean, std_dev converter.default_ranges_stats = (0, 255) tflite_model = converter.convert() open(osp.join(save_model_dir, 'quantized_frozen_graph.tflite'), "wb").write(tflite_model) ''' return # Training loop data_config = train_config['train_data_config'] total_steps = int(data_config['epoch'] * data_config['num_examples_per_epoch'] / data_config['batch_size']) logging.info('Train for {} steps'.format(total_steps)) save_step = int(data_config['num_examples_per_epoch'] / data_config['batch_size']) print("=========== save_step: {}".format(save_step)) for step in range(start_step, total_steps): start_time = time.time() # no "feed_dict" # has "feed_dict" exmaple (mnist): https://qiita.com/SwitchBlade/items/6677c283b2402d060cd0 _, loss, batch_loss, instances, response = sess.run([train_op, model.total_loss, model.batch_loss, model.instances, model.response]) duration = time.time() - start_time if step % 10 == 0: examples_per_sec = data_config['batch_size'] / float(duration) time_remain = data_config['batch_size'] * (total_steps - step) / examples_per_sec m, s = divmod(time_remain, 60) h, m = divmod(m, 60) format_str = ('%s: step %d, total loss = %.2f, batch loss = %.2f (%.1f examples/sec; %.3f ' 'sec/batch; %dh:%02dm:%02ds remains)') logging.info(format_str % (datetime.now(), step, loss, batch_loss, examples_per_sec, duration, h, m, s)) if step % 100 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) if step % save_step == 0 or (step + 1) == total_steps: checkpoint_path = osp.join(train_config['train_dir'], 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step)
def main(model_config, train_config, track_config): os.environ['CUDA_VISIBLE_DEVICES'] = auto_select_gpu() # Create training directory which will be used to save: configurations, model files, TensorBoard logs train_dir = train_config['train_dir'] if not osp.isdir(train_dir): logging.info('Creating training directory: %s', train_dir) mkdir_p(train_dir) g = tf.Graph() with g.as_default(): # Set fixed seed for reproducible experiments random.seed(train_config['seed']) np.random.seed(train_config['seed']) tf.set_random_seed(train_config['seed']) # Build the training and validation model model = siamese_model.SiameseModel(model_config, train_config, mode='train') model.build() model_va = siamese_model.SiameseModel(model_config, train_config, mode='validation') model_va.build(reuse=True) # Save configurations for future reference save_cfgs(train_dir, model_config, train_config, track_config) learning_rate = _configure_learning_rate(train_config, model.global_step) optimizer = _configure_optimizer(train_config, learning_rate) tf.summary.scalar('learning_rate', learning_rate) # Set up the training ops opt_op = tf.contrib.layers.optimize_loss( loss=model.total_loss, global_step=model.global_step, learning_rate=learning_rate, optimizer=optimizer, clip_gradients=train_config['clip_gradients'], learning_rate_decay_fn=None, summaries=['learning_rate']) with tf.control_dependencies([opt_op]): train_op = tf.no_op(name='train') saver = tf.train.Saver( tf.global_variables(), max_to_keep=train_config['max_checkpoints_to_keep']) summary_writer = tf.summary.FileWriter(train_dir, g) summary_op = tf.summary.merge_all() global_variables_init_op = tf.global_variables_initializer() local_variables_init_op = tf.local_variables_initializer() g.finalize() # Finalize graph to avoid adding ops by mistake # Dynamically allocate GPU memory gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) sess = tf.Session(config=sess_config) model_path = tf.train.latest_checkpoint(train_config['train_dir']) if not model_path: sess.run(global_variables_init_op) sess.run(local_variables_init_op) start_step = 0 if model_config['embed_config']['embedding_checkpoint_file']: model.init_fn(sess) else: logging.info('Restore from last checkpoint: {}'.format(model_path)) sess.run(local_variables_init_op) saver.restore(sess, model_path) start_step = tf.train.global_step(sess, model.global_step.name) + 1 # Training loop data_config = train_config['train_data_config'] total_steps = int(data_config['epoch'] * data_config['num_examples_per_epoch'] / data_config['batch_size']) logging.info('Train for {} steps'.format(total_steps)) for step in range(start_step, total_steps): start_time = time.time() _, loss, batch_loss = sess.run( [train_op, model.total_loss, model.batch_loss]) duration = time.time() - start_time if step % 10 == 0: examples_per_sec = data_config['batch_size'] / float(duration) time_remain = data_config['batch_size'] * ( total_steps - step) / examples_per_sec m, s = divmod(time_remain, 60) h, m = divmod(m, 60) format_str = ( '%s: step %d, total loss = %.2f, batch loss = %.2f (%.1f examples/sec; %.3f ' 'sec/batch; %dh:%02dm:%02ds remains)') logging.info(format_str % (datetime.now(), step, loss, batch_loss, examples_per_sec, duration, h, m, s)) if step % 100 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) if step % train_config['save_model_every_n_step'] == 0 or ( step + 1) == total_steps: checkpoint_path = osp.join(train_config['train_dir'], 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step)
""" gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) sess = tf.Session(graph=g, config=sess_config) """ sess = tf.Session(graph=g) restore_fn(sess) handle = vot.VOT("rectangle") selection = handle.region() imagefile = handle.frame() if not imagefile: sys.exit(0) trk = VOT_SIAM_Wrapper(model, sess, imagefile, selection, model_config, track_config) i = 0 path = osp.dirname(imagefile) path = osp.join(path, 'record') if not osp.isdir(path): mkdir_p(path) logdir = path while True: i = i + 1 imagefile = handle.frame() if not imagefile: break region = trk.track(imagefile, logdir, i) handle.report(region) sess.close()
def main(model_config, train_config): # Create training directory which will be used to save: configurations, model files, TensorBoard logs train_dir = train_config['train_dir'] if not osp.isdir(train_dir): logging.info('Creating training directory: %s', train_dir) mkdir_p(train_dir) g = tf.Graph() with g.as_default(): # Set fixed seed for reproducible experiments random.seed(train_config['seed']) np.random.seed(train_config['seed']) tf.set_random_seed(train_config['seed']) # Build the training and validation model model = BiseNet(model_config, train_config, train_config['num_classes'], mode="train") model.build(num_gpus=configuration.num_gpus, reuse=tf.AUTO_REUSE) model_va = BiseNet(model_config, train_config, train_config['num_classes'], mode="validation") model_va.build(reuse=True) # Save configurations for future reference save_cfgs(train_dir, model_config, train_config) learning_rate = _configure_learning_rate(train_config, model.global_step) optimizer = _configure_optimizer(train_config, learning_rate) tf.summary.scalar('learning_rate', learning_rate) # Set up the training ops tower_grads = [] for i in range(configuration.num_gpus): with tf.device('/gpu:%d' % i): name_scope = ('clone_%d' % i) if i else '' with tf.name_scope(name_scope) as scope: grads = optimizer.compute_gradients(model.total_loss[i]) tower_grads.append(grads) with tf.device('/cpu:0'): update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): grads_n_vars = _average_gradients(tower_grads) grad_updates = optimizer.apply_gradients( grads_n_vars, global_step=model.global_step) model.total_loss = tf.reduce_mean(model.total_loss) # update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) # update_ops.append(grad_updates) # update_op = tf.group(*update_ops) # with tf.control_dependencies(update_ops): # train_op = tf.contrib.layers.optimize_loss(loss=model.total_loss, # global_step=model.global_step, # learning_rate=learning_rate, # optimizer=optimizer, # clip_gradients=train_config['clip_gradients'], # learning_rate_decay_fn=None, # summaries=['learning_rate']) saver = tf.train.Saver( tf.global_variables(), max_to_keep=train_config['max_checkpoints_to_keep']) summary_writer = tf.summary.FileWriter(train_dir, g) summary_op = tf.summary.merge_all() global_variables_init_op = tf.global_variables_initializer() local_variables_init_op = tf.local_variables_initializer() g.finalize() # Finalize graph to avoid adding ops by mistake # Dynamically allocate GPU memory # gpu_options = tf.GPUOptions(allow_growth=True) # sess_config = tf.ConfigProto(gpu_options=gpu_options) # for multi gpu options. 'allow_soft_placement' must be set true sess_config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess_config.gpu_options.allow_growth = False sess = tf.Session(config=sess_config) model_path = tf.train.latest_checkpoint(train_config['train_dir']) if not model_path: sess.run(global_variables_init_op) sess.run(local_variables_init_op) start_step = 0 if model_config['frontend_config'][ 'pretrained_dir'] and model.init_fn: model.init_fn(sess) else: logging.info('Restore from last checkpoint: {}'.format(model_path)) sess.run(local_variables_init_op) saver.restore(sess, model_path) start_step = tf.train.global_step(sess, model.global_step.name) + 1 # Training loop data_config = train_config['train_data_config'] total_steps = int(data_config['epoch'] * data_config['num_examples_per_epoch'] / data_config['batch_size']) logging.info('Train for {} steps'.format(total_steps)) for step in range(start_step, total_steps): start_time = time.time() # _, loss = sess.run([train_op, model.total_loss]) _, loss = sess.run([grad_updates, model.total_loss]) duration = time.time() - start_time if step % 10 == 0: examples_per_sec = data_config['batch_size'] / float(duration) time_remain = data_config['batch_size'] * ( total_steps - step) / examples_per_sec m, s = divmod(time_remain, 60) h, m = divmod(m, 60) format_str = ( '%s: step %d, total loss = %.2f, (%.1f examples/sec; %.3f ' 'sec/batch; %dh:%02dm:%02ds remains)') logging.info(format_str % (datetime.now(), step, loss, examples_per_sec, duration, h, m, s)) if step % 10 == 0: summary_str = sess.run(summary_op) summary_writer.add_summary(summary_str, step) if step % train_config['save_model_every_n_step'] == 0 or ( step + 1) == total_steps: checkpoint_path = osp.join(train_config['train_dir'], 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step)
def download_or_skip(download_url, save_path): if not osp.exists(save_path): print('Downloading: {}'.format(download_url)) opener = urllib.request.URLopener() opener.retrieve(download_url, save_path) else: print('File {} exists, skip downloading.'.format(save_path)) if __name__ == '__main__': assets_dir = osp.join(ROOT_DIR, 'assets') # Make assets directory mkdir_p(assets_dir) # Download the pretrained color model download_base = 'https://www.robots.ox.ac.uk/~luca/stuff/siam-fc_nets/' model_name = '2016-08-17.net.mat' download_or_skip(download_base + model_name, osp.join(assets_dir, model_name)) # Download the pretrained gray model download_base = 'https://www.robots.ox.ac.uk/~luca/stuff/siam-fc_nets/' model_name = '2016-08-17_gray025.net.mat' download_or_skip(download_base + model_name, osp.join(assets_dir, model_name)) # Download one test sequence download_base = "http://cvlab.hanyang.ac.kr/tracker_benchmark/seq_new/"