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/"
