def create_architecture_adversarial(cfg, batch_size, multiplier_lst,
logits_budget_lst_dct, loss_budget_lst_dct,
scope, videos, utility_labels,
budget_labels, dropout):
'''
Create the architecture of the adversarial model in the graph
is_training: whether it is in the adversarial training part. (include testing, not two-fold)
'''
# fd part:
degrad_videos = residualNet(videos, is_video=True)
degrad_videos = _avg_replicate(
degrad_videos) if FLAGS.use_avg_replicate else degrad_videos
# fd part ends
# fT part:
logits_utility = utilityNet(degrad_videos, dropout, wd=0.001)
loss_utility = tower_loss_xentropy_sparse(scope,
logits_utility,
utility_labels,
use_weight_decay=True)
# fT part ends
# fb part:
logits_budget = tf.zeros([batch_size, cfg['DATA']['NUM_CLASSES_BUDGET']])
loss_budget = 0.0
budget_logits_lst = []
for multiplier in multiplier_lst:
print(multiplier)
logits = budgetNet(degrad_videos, depth_multiplier=multiplier)
budget_logits_lst.append(logits)
loss = tower_loss_xentropy_sparse(scope,
logits,
budget_labels,
use_weight_decay=False)
logits_budget_lst_dct[str(multiplier)].append(logits)
loss_budget_lst_dct[str(multiplier)].append(loss)
logits_budget += logits / FLAGS.NBudget
loss_budget += loss / FLAGS.NBudget
# fd part ends.
# Find the largest budget loss of the M ensembled budget models:
argmax_adverse_budget_loss = None
# finish finding max_adverse_budget_loss and argmax_adverse_budget_loss.
# change the definition of loss_degrad:
loss_degrad = -loss_budget
return loss_degrad, loss_budget, loss_utility, logits_budget, logits_utility, argmax_adverse_budget_loss
def create_architecture_adversarial(scope, videos, budget_labels, istraining_placeholder): ''' Create the architecture of the adversarial model in the graph Args: is_training: whether it is in the adversarial training part. (include testing, not two-fold) ''' # fd part: degrad_videos = residualNet(videos, is_video=True) degrad_videos = _avg_replicate(degrad_videos) if FLAGS.use_avg_replicate else degrad_videos # fd part ends # fb part: loss_budget = 0.0 logits_budget = tf.zeros([TRAIN_BATCH_SIZE, COMMON_FLAGS.NUM_CLASSES_BUDGET]) logits = budgetNet(degrad_videos, depth_multiplier=0.6, is_training=istraining_placeholder) loss = tower_loss_xentropy_sparse(logits, budget_labels, use_weight_decay=False, name_scope=scope) logits_budget += logits loss_budget += loss # fd part ends. return loss_budget, logits_budget
def visualize_degradation(checkpoint_dir):
cfg = yaml.load(open('params.yml'))
pp = pprint.PrettyPrinter()
pp.pprint(cfg)
if not os.path.exists(cfg['VIS_DIR']):
os.makedirs(cfg['VIS_DIR'])
videos_placeholder = tf.placeholder(
tf.float32,
shape=(cfg['BATCH_SIZE'] * cfg['GPU_NUM'], cfg['DEPTH'], 112, 112,
cfg['NCHANNEL']))
videos_degraded_lst = []
with tf.variable_scope(tf.get_variable_scope()) as scope:
for gpu_index in range(0, cfg['GPU_NUM']):
with tf.device('/gpu:%d' % gpu_index):
print('/gpu:%d' % gpu_index)
with tf.name_scope('%s_%d' % ('gpu', gpu_index)) as scope:
videos_degraded = residualNet(
videos_placeholder[gpu_index *
cfg['BATCH_SIZE']:(gpu_index + 1) *
cfg['BATCH_SIZE']],
is_video=True)
if cfg['USE_AVG_REPLICATE']:
videos_degraded = _avg_replicate(videos_degraded)
videos_degraded_lst.append(videos_degraded)
# Reuse variables for the next tower.
tf.get_variable_scope().reuse_variables()
videos_degraded_op = tf.concat(videos_degraded_lst, 0)
train_files = [
os.path.join(cfg['TRAIN_FILES_DIR'], f)
for f in os.listdir(cfg['TRAIN_FILES_DIR']) if f.endswith('.tfrecords')
]
val_files = [
os.path.join(cfg['VAL_FILES_DIR'], f)
for f in os.listdir(cfg['VAL_FILES_DIR']) if f.endswith('.tfrecords')
]
print(train_files)
print(val_files)
videos_op, action_labels_op, actor_labels_op = inputs_videos(
filenames=val_files,
batch_size=cfg['GPU_NUM'] * cfg['BATCH_SIZE'],
num_epochs=1,
num_threads=cfg['NUM_THREADS'],
num_examples_per_epoch=cfg['NUM_EXAMPLES_PER_EPOCH'],
shuffle=False)
config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
sess.run(init_op)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
saver = tf.train.Saver(tf.trainable_variables())
ckpt = tf.train.get_checkpoint_state(checkpoint_dir=checkpoint_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print('Session restored from trained model at {}!'.format(
ckpt.model_checkpoint_path))
else:
raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
checkpoint_dir)
try:
#videos_degraded_lst = []
#action_labels_lst = []
#actor_labels_lst = []
directory = cfg['VIS_DIR']
while not coord.should_stop():
videos, action_labels, actor_labels = sess.run(
[videos_op, action_labels_op, actor_labels_op])
videos_degraded_value = sess.run(
videos_degraded_op, feed_dict={videos_placeholder: videos})
videos.tolist()
videos_degraded_value.tolist()
#videos_degraded_lst.append(videos_degraded_value*255)
#videos_degraded_lst.extend(videos_degraded_value)
#action_labels_lst.extend(action_labels)
#actor_labels_lst.extend(actor_labels)
visualize(directory, videos_degraded_value, videos,
action_labels, actor_labels)
#raise tf.errors.OutOfRangeError
except tf.errors.OutOfRangeError:
print('Done testing on all the examples')
finally:
coord.request_stop()
coord.join(threads)
def run_training(cfg, degrad_ckpt_file, ckpt_dir, model_name, max_steps,
train_from_scratch, ckpt_path):
# Create model directory
if not os.path.exists(ckpt_dir):
os.makedirs(ckpt_dir)
continue_from_trained_model = False
config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
config.gpu_options.allow_growth = True
network_fn = nets_factory.get_network_fn(
model_name,
num_classes=cfg['DATA']['NUM_CLASSES'],
weight_decay=cfg['TRAIN']['WEIGHT_DECAY'],
is_training=True)
with tf.Graph().as_default():
with tf.Session(config=config) as sess:
global_step = tf.get_variable(
'global_step', [],
initializer=tf.constant_initializer(0),
trainable=False)
videos_placeholder, labels_placeholder, istraining_placeholder = placeholder_inputs(
cfg['DATA']['BATCH_SIZE'] * cfg['TRAIN']['GPU_NUM'])
tower_grads = []
logits_lst = []
losses_lst = []
opt = tf.train.AdamOptimizer(1e-4)
with tf.variable_scope(tf.get_variable_scope()) as scope:
for gpu_index in range(0, cfg['TRAIN']['GPU_NUM']):
with tf.device('/gpu:%d' % gpu_index):
print('/gpu:%d' % gpu_index)
with tf.name_scope('%s_%d' %
('gpu', gpu_index)) as scope:
degrad_videos = residualNet(
videos_placeholder[gpu_index *
cfg['TRAIN']['BATCH_SIZE']:
(gpu_index + 1) *
cfg['TRAIN']['BATCH_SIZE']],
is_video=True)
degrad_videos = tf.reshape(degrad_videos, [
cfg['TRAIN']['BATCH_SIZE'] *
cfg['DATA']['DEPTH'], cfg['DATA']['HEIGHT'],
cfg['DATA']['WIDTH'], cfg['DATA']['NCHANNEL']
])
logits, _ = network_fn(degrad_videos)
logits = tf.reshape(logits, [
-1, cfg['DATA']['DEPTH'],
cfg['DATA']['NUM_CLASSES']
])
logits = tf.reduce_mean(logits,
axis=1,
keep_dims=False)
logits_lst.append(logits)
loss = tower_loss_xentropy_sparse(
scope,
logits,
labels=labels_placeholder[
gpu_index *
cfg['TRAIN']['BATCH_SIZE']:(gpu_index +
1) *
cfg['TRAIN']['BATCH_SIZE'], :])
logits_lst.append(logits)
losses_lst.append(loss)
print([v.name for v in tf.trainable_variables()])
varlist_budget = [
v for v in tf.trainable_variables()
if any(x in v.name for x in [
"InceptionV1", "InceptionV2",
"resnet_v1_50", "resnet_v1_101",
"resnet_v2_50", "resnet_v2_101",
"MobilenetV1_1.0", "MobilenetV1_0.75",
"MobilenetV1_0.5", 'MobilenetV1_0.25'
])
]
varlist_degrad = [
v for v in tf.trainable_variables()
if v not in varlist_budget
]
tower_grads.append(
opt.compute_gradients(loss, varlist_budget))
tf.get_variable_scope().reuse_variables()
loss_op = tf.reduce_mean(losses_lst)
logits_op = tf.concat(logits_lst, 0)
acc_op = accuracy(logits_op, labels_placeholder)
grads = average_gradients(tower_grads)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
print(update_ops)
with tf.control_dependencies([tf.group(*update_ops)]):
train_op = opt.apply_gradients(grads, global_step=global_step)
train_files = [
os.path.join(cfg['DATA']['TRAIN_FILES_DIR'], f)
for f in os.listdir(cfg['DATA']['TRAIN_FILES_DIR'])
if f.endswith('.tfrecords')
]
val_files = [
os.path.join(cfg['DATA']['VAL_FILES_DIR'], f)
for f in os.listdir(cfg['DATA']['VAL_FILES_DIR'])
if f.endswith('.tfrecords')
]
print(
'#############################Reading from files###############################'
)
print(train_files)
print(val_files)
tr_videos_op, _, tr_labels_op = inputs_videos(
filenames=train_files,
batch_size=cfg['TRAIN']['BATCH_SIZE'] *
cfg['TRAIN']['BATCH_SIZE'],
num_epochs=None,
num_threads=cfg['DATA']['NUM_THREADS'],
num_examples_per_epoch=cfg['TRAIN']['NUM_EXAMPLES_PER_EPOCH'],
shuffle=True)
val_videos_op, _, val_labels_op = inputs_videos(
filenames=val_files,
batch_size=cfg['TRAIN']['BATCH_SIZE'] *
cfg['TRAIN']['BATCH_SIZE'],
num_epochs=None,
num_threads=cfg['DATA']['NUM_THREADS'],
num_examples_per_epoch=cfg['TRAIN']['NUM_EXAMPLES_PER_EPOCH'],
shuffle=True)
init_op = tf.group(tf.local_variables_initializer(),
tf.global_variables_initializer())
sess.run(init_op)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
gvar_list = tf.global_variables()
bn_moving_vars = [g for g in gvar_list if 'moving_mean' in g.name]
bn_moving_vars += [
g for g in gvar_list if 'moving_variance' in g.name
]
print([var.name for var in bn_moving_vars])
def restore_model(dir, varlist, modulename):
import re
regex = re.compile(r'(MobilenetV1_?)(\d*\.?\d*)',
re.IGNORECASE)
if 'mobilenet' in modulename:
varlist = {
regex.sub('MobilenetV1', v.name[:-2]): v
for v in varlist
}
if os.path.isfile(dir):
print(varlist)
saver = tf.train.Saver(varlist)
saver.restore(sess, dir)
print(
'#############################Session restored from pretrained model at {}!#############################'
.format(dir))
else:
ckpt = tf.train.get_checkpoint_state(checkpoint_dir=dir)
if ckpt and ckpt.model_checkpoint_path:
saver = tf.train.Saver(varlist)
saver.restore(sess, ckpt.model_checkpoint_path)
print(
'#############################Session restored from pretrained model at {}!#############################'
.format(ckpt.model_checkpoint_path))
if continue_from_trained_model:
varlist = varlist_budget
varlist += bn_moving_vars
saver = tf.train.Saver(varlist)
ckpt = tf.train.get_checkpoint_state(checkpoint_dir=ckpt_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print(
'#############################Session restored from trained model at {}!###############################'
.format(ckpt.model_checkpoint_path))
else:
raise FileNotFoundError(errno.ENOENT,
os.strerror(errno.ENOENT),
ckpt_dir)
else:
if not train_from_scratch:
saver = tf.train.Saver(varlist_degrad)
print(degrad_ckpt_file)
saver.restore(sess, degrad_ckpt_file)
varlist = [
v for v in varlist_budget + bn_moving_vars
if not any(x in v.name for x in ["logits"])
]
restore_model(ckpt_path, varlist, model_name)
saver = tf.train.Saver(tf.trainable_variables() + bn_moving_vars,
max_to_keep=1)
for step in xrange(max_steps):
start_time = time.time()
train_videos, train_labels = sess.run(
[tr_videos_op, tr_labels_op])
_, loss_value = sess.run(
[train_op, loss_op],
feed_dict={
videos_placeholder: train_videos,
labels_placeholder: train_labels,
istraining_placeholder: True
})
assert not np.isnan(
np.mean(loss_value)), 'Model diverged with loss = NaN'
duration = time.time() - start_time
print('Step: {:4d} time: {:.4f} loss: {:.8f}'.format(
step, duration, np.mean(loss_value)))
if step % cfg['TRAIN']['VAL_STEP'] == 0:
start_time = time.time()
tr_videos, tr_labels = sess.run(
[tr_videos_op, tr_labels_op])
acc, loss_value = sess.run(
[acc_op, loss_op],
feed_dict={
videos_placeholder: tr_videos,
labels_placeholder: tr_labels,
istraining_placeholder: False
})
print(
"Step: {:4d} time: {:.4f}, training accuracy: {:.5f}, loss: {:.8f}"
.format(step,
time.time() - start_time, acc, loss_value))
# train_writer.add_summary(summary, step)
start_time = time.time()
val_videos, val_labels = sess.run(
[val_videos_op, val_labels_op])
acc, loss_value = sess.run(
[acc_op, loss_op],
feed_dict={
videos_placeholder: val_videos,
labels_placeholder: val_labels,
istraining_placeholder: False
})
print(
"Step: {:4d} time: {:.4f}, validation accuracy: {:.5f}, loss: {:.8f}"
.format(step,
time.time() - start_time, acc, loss_value))
# test_writer.add_summary(summary, step)
# Save a checkpoint and evaluate the model periodically.
if step % cfg['TRAIN']['SAVE_STEP'] == 0 or (
step + 1) == cfg['TRAIN']['MAX_STEPS']:
checkpoint_path = os.path.join(ckpt_dir, 'model.ckpt')
saver.save(sess, checkpoint_path, global_step=step)
coord.request_stop()
coord.join(threads)
print("done")
def run_testing(cfg, degrad_ckpt_file, ckpt_dir, model_name, is_training):
config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
config.gpu_options.allow_growth = True
network_fn = nets_factory.get_network_fn(
model_name,
num_classes=cfg['DATA']['NUM_CLASSES'],
weight_decay=cfg['TRAIN']['WEIGHT_DECAY'],
is_training=True)
with tf.Graph().as_default():
with tf.Session(config=config) as sess:
global_step = tf.get_variable(
'global_step', [],
initializer=tf.constant_initializer(0),
trainable=False)
videos_placeholder, _, labels_placeholder, _, _ = placeholder_inputs(
cfg['DATA']['BATCH_SIZE'] * cfg['TRAIN']['GPU_NUM'])
istraining_placeholder = tf.placeholder(tf.bool)
logits_lst = []
with tf.variable_scope(tf.get_variable_scope()) as scope:
for gpu_index in range(0, cfg['TRAIN']['GPU_NUM']):
with tf.device('/gpu:%d' % gpu_index):
print('/gpu:%d' % gpu_index)
with tf.name_scope('%s_%d' %
('gpu', gpu_index)) as scope:
degrad_videos = residualNet(
videos_placeholder[gpu_index *
cfg['TRAIN']['BATCH_SIZE']:
(gpu_index + 1) *
cfg['TRAIN']['BATCH_SIZE']],
is_video=True)
degrad_videos = tf.reshape(degrad_videos, [
cfg['TRAIN']['BATCH_SIZE'] *
cfg['DATA']['DEPTH'], cfg['DATA']['HEIGHT'],
cfg['DATA']['WIDTH'], cfg['DATA']['NCHANNEL']
])
logits, _ = network_fn(degrad_videos)
logits = tf.reshape(logits, [
-1, cfg['DATA']['DEPTH'],
cfg['DATA']['NUM_CLASSES']
])
logits = tf.reduce_mean(logits,
axis=1,
keep_dims=False)
logits_lst.append(logits)
tf.get_variable_scope().reuse_variables()
logits_op = tf.concat(logits_lst, 0)
right_count_op = tf.reduce_sum(
tf.cast(
tf.equal(tf.argmax(tf.nn.softmax(logits_op), axis=1),
labels_placeholder), tf.int32))
softmax_logits_op = tf.nn.softmax(logits_op)
train_files = [
os.path.join(cfg['DATA']['TRAIN_FILES_DIR'], f)
for f in os.listdir(cfg['DATA']['TRAIN_FILES_DIR'])
if f.endswith('.tfrecords')
]
val_files = [
os.path.join(cfg['DATA']['VAL_FILES_DIR'], f)
for f in os.listdir(cfg['DATA']['VAL_FILES_DIR'])
if f.endswith('.tfrecords')
]
print(
'#############################Reading from files###############################'
)
print(train_files)
print(val_files)
print(
'#############################Reading from files###############################'
)
print(train_files)
print(val_files)
if is_training:
videos_op, _, labels_op = inputs_videos(
filenames=train_files,
batch_size=cfg['TRAIN']['BATCH_SIZE'] *
cfg['TRAIN']['BATCH_SIZE'],
num_epochs=None,
num_threads=cfg['DATA']['NUM_THREADS'],
num_examples_per_epoch=cfg['TRAIN']
['NUM_EXAMPLES_PER_EPOCH'],
shuffle=False)
else:
videos_op, _, labels_op = inputs_videos(
filenames=val_files,
batch_size=cfg['TRAIN']['BATCH_SIZE'] *
cfg['TRAIN']['BATCH_SIZE'],
num_epochs=None,
num_threads=cfg['DATA']['NUM_THREADS'],
num_examples_per_epoch=cfg['TRAIN']
['NUM_EXAMPLES_PER_EPOCH'],
shuffle=False)
init_op = tf.group(tf.local_variables_initializer(),
tf.global_variables_initializer())
sess.run(init_op)
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
varlist_budget = [
v for v in tf.trainable_variables()
if any(x in v.name for x in [
"InceptionV1", "InceptionV2", "resnet_v1_50",
"resnet_v1_101", "resnet_v2_50", "resnet_v2_101",
"MobilenetV1_1.0", "MobilenetV1_0.75", "MobilenetV1_0.5",
'MobilenetV1_0.25'
])
]
varlist_degrad = [
v for v in tf.trainable_variables() if v not in varlist_budget
]
saver = tf.train.Saver(varlist_degrad)
saver.restore(sess, degrad_ckpt_file)
gvar_list = tf.global_variables()
bn_moving_vars = [g for g in gvar_list if 'moving_mean' in g.name]
bn_moving_vars += [
g for g in gvar_list if 'moving_variance' in g.name
]
saver = tf.train.Saver(tf.trainable_variables() + bn_moving_vars)
ckpt = tf.train.get_checkpoint_state(checkpoint_dir=ckpt_dir)
if ckpt and ckpt.model_checkpoint_path:
saver.restore(sess, ckpt.model_checkpoint_path)
print('Session restored from pretrained budget model at {}!'.
format(ckpt.model_checkpoint_path))
else:
raise FileNotFoundError(errno.ENOENT,
os.strerror(errno.ENOENT), ckpt_dir)
total_v = 0.0
test_correct_num = 0.0
try:
while not coord.should_stop():
videos, labels = sess.run([videos_op, labels_op])
# write_video(videos, labels)
feed = {
videos_placeholder: videos,
labels_placeholder: labels,
istraining_placeholder: False
}
right, softmax_logits = sess.run(
[right_count_op, softmax_logits_op], feed_dict=feed)
test_correct_num += right
total_v += labels.shape[0]
print(softmax_logits.shape)
# print(tf.argmax(softmax_logits, 1).eval(session=sess))
# print(logits.eval(feed_dict=feed, session=sess))
# print(labels)
except tf.errors.OutOfRangeError:
print('Done testing on all the examples')
finally:
coord.request_stop()
print('test acc:', test_correct_num / total_v, 'test_correct_num:',
test_correct_num, 'total_v:', total_v)
with open('TwoFoldEvaluationResults_{}.txt'.format(model_name),
'w') as wf:
wf.write('test acc: {}\ttest_correct_num:{}\ttotal_v\n'.format(
test_correct_num / total_v, test_correct_num, total_v))
coord.join(threads)
sess.close()
print("done")
def build_graph(model_name):
'''
Returns:
graph, init_op, train_op,
logits_op, acc_op, correct_count_op, loss_op,
tr_videos_op, tr_actor_labels_op, val_videos_op, val_actor_labels_op, test_videos_op, test_actor_labels_op,
videos_placeholder, labels_placeholder,
varlist_budget, varlist_degrad
'''
graph = tf.Graph()
with graph.as_default():
# global step:
global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False)
# placholder inputs for graph:
videos_placeholder, labels_placeholder, istraining_placeholder = placeholder_inputs(cfg['TRAIN']['BATCH_SIZE'] * FLAGS.GPU_NUM, cfg)
# degradation models:
network_fn = nets_factory.get_network_fn(model_name,
num_classes=cfg['DATA']['NUM_CLASSES'],
weight_decay=cfg['TRAIN']['WEIGHT_DECAY'],
is_training=istraining_placeholder)
# grads, logits, loss list:
tower_grads = []
logits_lst = []
losses_lst = []
# operation method:
opt = tf.train.AdamOptimizer(1e-4)
with tf.variable_scope(tf.get_variable_scope()) as scope:
for gpu_index in range(0, FLAGS.GPU_NUM):
with tf.device('/gpu:%d' % gpu_index):
print('/gpu:%d' % gpu_index)
with tf.name_scope('%s_%d' % ('gpu', gpu_index)) as scope:
videos = videos_placeholder[gpu_index * cfg['TRAIN']['BATCH_SIZE']:(gpu_index + 1) * cfg['TRAIN']['BATCH_SIZE']]
budget_labels = labels_placeholder[gpu_index * cfg['TRAIN']['BATCH_SIZE']:(gpu_index + 1) * cfg['TRAIN']['BATCH_SIZE']]
degrad_videos = residualNet(videos, is_video=True)
degrad_videos = tf.reshape(degrad_videos, [cfg['TRAIN']['BATCH_SIZE'] * cfg['DATA']['DEPTH'], cfg['DATA']['CROP_HEIGHT'], cfg['DATA']['CROP_WIDTH'], cfg['DATA']['NCHANNEL']])
# logits:
logits, _ = network_fn(degrad_videos)
logits = tf.reshape(logits, [-1, cfg['DATA']['DEPTH'], cfg['DATA']['NUM_CLASSES']])
logits = tf.reduce_mean(logits, axis=1, keep_dims=False)
# loss:
loss = tower_loss_xentropy_sparse(scope, logits, budget_labels)
# append list:
logits_lst.append(logits)
losses_lst.append(loss)
# varible list of budget model:
varlist_budget = [v for v in tf.trainable_variables() if
any(x in v.name for x in ["InceptionV1", "InceptionV2",
"resnet_v1_50", "resnet_v1_101", "resnet_v2_50", "resnet_v2_101",
'MobilenetV1'])]
# varible list of degrade model:
varlist_degrad = [v for v in tf.trainable_variables() if v not in varlist_budget]
# append grads:
tower_grads.append(opt.compute_gradients(loss, varlist_budget))
# reuse variables:
tf.get_variable_scope().reuse_variables()
# loss tensor:
loss_op = tf.reduce_mean(losses_lst)
# acc tensor:
logits_op = tf.concat(logits_lst, 0)
acc_op = accuracy(logits_op, labels_placeholder)
# how many is correctly classified:
correct_count_op = tf.reduce_sum(
tf.cast(tf.equal(tf.argmax(tf.nn.softmax(logits_op), axis=1), labels_placeholder), tf.int32))
# grads tensor:
grads = average_gradients(tower_grads) # average gradient over all GPUs
# apply gradients operation:
with tf.control_dependencies([tf.group(*tf.get_collection(tf.GraphKeys.UPDATE_OPS))]):
train_op = opt.apply_gradients(grads, global_step=global_step)
# input operations:
tr_videos_op, _, tr_actor_labels_op = create_videos_reading_ops(is_train=True, is_val=False, cfg=cfg)
val_videos_op, _, val_actor_labels_op = create_videos_reading_ops(is_train=False, is_val=True, cfg=cfg)
test_videos_op, _, test_actor_labels_op = create_videos_reading_ops(is_train=False, is_val=False, cfg=cfg)
# initialize operations:
init_op = tf.group(tf.local_variables_initializer(), tf.global_variables_initializer())
return (graph, init_op, train_op,
logits_op, acc_op, correct_count_op, loss_op,
tr_videos_op, tr_actor_labels_op, val_videos_op, val_actor_labels_op, test_videos_op, test_actor_labels_op,
videos_placeholder, labels_placeholder, istraining_placeholder,
varlist_budget, varlist_degrad)